using RxjhServer.DbClss;
using RxjhServer.HelperTools;
using RxjhServer.Network;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace RxjhServer
{
	public class World
	{
		public static string[] 移动速度;

		public static float 走;

		public static float 跑;

		public static float 轻功15;

		public static float 轻功60;

		public static float 轻功100;

		public static float 骑宠1;

		public static float 骑宠2;

		public static float 骑宠3;

		public static int 红字标识;

		public static int 新手上线礼包;

		public static int 物品数据;

		public static int 势力战准备时间分钟;

		public static int 势力战正人数;

		public static int 势力战邪人数;

		public static int 假人势力战参与人数;

		public static int BOSS假人参与数;

		public static int 离线数量;

		public static int 离线假人;

		public static int 攻击模式;

		public static int 延迟死亡间隔;

		public static List<TBL_假人出售物品> 假人出售物品列表;

		public static int 假人上线获得装备模式;

		public static int 假人参与BOSS开关;

		public static int 假人气功开关;

		public static int 假人加入门派;

		public static int 假人获得武勋;

		public static int 假人接受组队;

		public static int 假人发呆提示;

		public static int 假人死亡提示;

		public static int 等级相差提示;

		public static int 假人自动结婚;

		public static int 假人打怪喊话;

		public static int 假人是否参加势力战;

		public static int 是否给假人开安全模式;

		public static int 全部假人安全模式;

		public static int 假人获得武勋计时器;

		public static int 假人死亡几次换位置;

		public static int 假人PK功能是否开启;

		public static int 是否给假人武器强化;

		public static int 假人自动转生;

		public static int 假人自动转生计时器;

		public static string 机器人门主名称一;

		public static string 机器人帮派名称一;

		public static string 机器人门主名称二;

		public static string 机器人帮派名称二;

		public static string 机器人门主名称三;

		public static string 机器人帮派名称三;

		public static string 机器人门主名称四;

		public static string 机器人帮派名称四;

		public static string 机器人门主名称五;

		public static string 机器人帮派名称五;

		public static int 机器人门主等级;

		public static int 死亡扣除武勋;

		public static int 杀人获得武勋;

		public static int 离线挂机数量;

		public static double 会员经验百分比;

		public static double 会员金钱百分比;

		public static double 会员历练百分比;

		public static double 会员爆率百分比;

		public static string 自定义挂机地图;

		public static string 自定义挂机地图坐标;

		public static int 自动解封是否开启1;

		public static int 自动解封时1;

		public static int 自动解封分1;

		public static string 自动解封等级1;

		public static int 自动解封日期1;

		public static int 自动解封判断1;

		public static int 自动封印天数1;

		public static int 自动解封是否开启2;

		public static int 自动解封时2;

		public static int 自动解封分2;

		public static string 自动解封等级2;

		public static int 自动解封日期2;

		public static int 自动解封判断2;

		public static int 自动封印天数2;

		public static int 自动解封是否开启3;

		public static int 自动解封时3;

		public static int 自动解封分3;

		public static string 自动解封等级3;

		public static int 自动解封日期3;

		public static int 自动解封判断3;

		public static int 自动封印天数3;

		public static int 自动解封是否开启4;

		public static int 自动解封时4;

		public static int 自动解封分4;

		public static string 自动解封等级4;

		public static int 自动解封日期4;

		public static int 自动解封判断4;

		public static int 自动封印天数4;

		public static int 会员专用地图;

		public static int 被杀武勋限制;

		public static int 被杀武勋清零时;

		public static int 被杀武勋清零分;

		public static int 攻城战星期几开;

		public static int 喊话等级限制;

		public static int 攻城战BUFF有效期;

		public static int 是否开启物品回收;

		public static int 弓全队678;

		public static int 收宠机率;

		public static string 收宠所需ID;

		public static string[] 宠物加属性1;

		public static string[] 宠物加属性10;

		public static string[] 宠物加属性2;

		public static string[] 宠物加属性3;

		public static string[] 宠物加属性4;

		public static string[] 宠物加属性5;

		public static string[] 宠物加属性6;

		public static string[] 宠物加属性7;

		public static string[] 宠物加属性8;

		public static string[] 宠物加属性9;

		public static string 宠物进阶保护;

		public static string 野宠进阶成功率;

		public static string 宠物进阶公告;

		public static string 宠物进阶所需物品ID;

		public static int 宠物进阶最阶段;

		public static string 抓宠命令;

		public static string 定点命令;

		public static string 召唤命令;

		public static string 召回命令;

		public static string 跟随命令;

		public static string 进阶命令;

		public static string 放生命令;

		public static int 时间系统开关;

		public static int 世界时间;

		public static List<首爆石头> Set首爆石头;

		public static List<首爆> Set首爆;

		public static List<自定义回收> Sst自定义回收;

		public static long 金刚石攻击;

		public static long 金刚石命中;

		public static long 金刚石生命;

		public static long 金刚石武功;

		public static long 金刚石气功;

		public static long 金刚石追伤;

		public static long 寒玉石防御;

		public static long 寒玉石回避;

		public static long 寒玉石内功;

		public static int 寒玉石武防;

		public static long 寒玉石生命;

		public static long 混元金刚石攻击;

		public static long 混元金刚石气功;

		public static long 混元金刚石命中;

		public static long 混元金刚石生命;

		public static long 混元金刚石武功;

		public static long 混元金刚石追伤;

		public static long 冰魄寒玉石防御;

		public static long 冰魄寒玉石回避;

		public static long 冰魄寒玉石内功;

		public static long 冰魄寒玉石武防;

		public static long 冰魄寒玉石生命;

		public static long 热血石气功;

		public static string 挂机打怪自动发言;

		public static string VIP挂机奖励;

		public static int VIP挂机奖励最大元宝;

		public static int VIP挂机奖励最大武勋;

		public static string 离线挂机命令;

		public static int 是否开启离线挂机;

		public static int 离线挂机等级;

		public static string 离线挂机所需物品ID;

		public static int 离线挂机地图;

		public static int 离线挂机经验是否开启;

		public static int 离线挂机经验限制最低等级;

		public static int 离线挂机奖励经验时间;

		public static int 离线挂机经验数;

		public static string 离线挂机奖励;

		public static string 离线VIP挂机奖励;

		public static int 离线挂机奖励是否开启;

		public static int 离线挂机奖励限制最低等级;

		public static int 离线挂机奖励发送时间间隔;

		public static int 挂机奖励是否开启;

		public static string 在线挂机打怪命令;

		public static string 停止挂机打怪命令;

		public static double 灵甲护身加成;

		public static int 气功是否有效;

		public static int 医生运气疗伤加血量;

		public static int 医生回气疗伤加血量;

		public static int 医生聚气疗伤加血量;

		public static double 刀力劈华山;

		public static double 弓箭平A伤害;

		public static double 刀摄魂一击;

		public static double 刀连环飞舞概率;

		public static double 剑连环飞舞概率;

		public static double 枪连环飞舞概率;

		public static double 刀必杀一击概率;

		public static double 剑必杀一击概率;

		public static double 枪必杀一击概率;

		public static double 弓必杀一击概率;

		public static double 刀四两千金概率;

		public static double 刀霸气破甲概率;

		public static double 刀霸气破甲效果;

		public static double 刀真武绝技概率;

		public static double 刀真武绝技伤害;

		public static double 刀暗影绝杀概率;

		public static double 刀暗影绝杀伤害;

		public static double 刀流光万舞伤害;

		public static double 剑长虹贯日攻击;

		public static double 剑百变神行概率;

		public static double 剑护身罡气概率;

		public static double 剑回柳身法武功;

		public static double 剑移花接木概率;

		public static double 剑回柳身法概率;

		public static double 剑怒海狂澜概率;

		public static double 剑冲冠一怒概率;

		public static double 剑无坚不摧概率;

		public static double 剑无坚不摧效果;

		public static double 枪金钟罡气;

		public static double 枪运气疗伤;

		public static double 枪横练太保;

		public static double 枪乾坤挪移;

		public static double 枪灵甲护身;

		public static double 枪狂神降世;

		public static double 枪转攻为守;

		public static double 枪末日狂舞;

		public static double 弓百步穿杨;

		public static double 弓凝神聚气;

		public static double 弓心神凝聚概率;

		public static double 弓心神凝聚伤害;

		public static double 弓流星三矢概率;

		public static double 弓锐利之箭;

		public static double 弓无明暗矢概率;

		public static double 弓致命绝杀概率;

		public static double 弓致命绝杀伤害;

		public static double 医运气行心;

		public static double 体血倍增;

		public static double 洗髓易筋;

		public static double 医长攻击力;

		public static double 医吸星大法;

		public static double 医天佑之气;

		public static double 医九天真气;

		public static double 医万物回春;

		public static string 再造寒玉石防御;

		public static string 商店神秘金刚石武功;

		public static string 商店神秘金刚石追伤;

		public static string 商店混元金刚石;

		public static string 商店冰魄寒玉石防御;

		public static string 商店冰魄寒玉石武功防御;

		public static int 商店属性石;

		public static int 商店属性石概率控制开启;

		public static int 出火属性石概率值;

		public static int 是否开启寒玉石随机属性;

		public static int 是否开启金刚石随机属性;

		public static string 商店神秘金刚石;

		public static string 商店神秘寒玉石;

		public static string 商店神秘寒玉石生命;

		public static string 商店神秘寒玉石武防;

		public static string 再造寒玉石回避;

		public static string 再造寒玉石内功;

		public static string 再造寒玉石生命;

		public static string 再造寒玉石武防;

		public static string 再造金刚石攻击;

		public static string 再造金刚石命中;

		public static string 再造金刚石生命;

		public static string 再造金刚石武功;

		public static string 再造金刚石追伤;

		public static string 再造混元金刚石武功;

		public static string 再造混元金刚石攻击;

		public static string 再造冰魄寒玉石防御;

		public static string 再造冰魄寒玉石武防;

		public static int 每次再造消耗设置;

		public static int 是否开启全服开箱提示;

		public static int 全服开箱掉落颜色提示;

		public static int 是否开启全服掉落提示;

		public static int 是否开启全服上线提示;

		public static string 摸金提示内容;

		public static int 是否开启摸金副本地图;

		public static int 刀客无爆率;

		public static int 剑客无爆率;

		public static int 枪客无爆率;

		public static int 弓箭手无爆率;

		public static int 医生无爆率;

		public static int 创建门派需要金钱;

		public static Dictionary<string, 文本兑换类> 文本兑换;

		public static ThreadSafeDictionary<int, 客户端IP地址> Iplist;

		public static string 信任连接IP;

		public static int 允许多开数量;

		public static int 全服土豪需要元宝;

		public static int 全服土豪需要积分;

		public static int 队伍土豪需要金币;

		public static int 队伍土豪需要积分;

		public static int 队伍土豪需要元宝;

		public static int 是否开启土豪系统;

		public static int 土豪经验金币数;

		public static double 土豪经验百分比;

		public static double 土豪爆率百分比;

		public static int 土豪经验持续时间;

		public static double 队伍经验百分比;

		public static double 队伍爆率百分比;

		public static int 队伍经验持续时间;

		public static int 门派经验金币数;

		public static int 门派经验积分数;

		public static int 门派经验元宝数;

		public static double 门派经验百分比;

		public static double 门派爆率百分比;

		public static int 门派经验持续时间;

		public static int 坐牢系统是否开启;

		public static string 坐牢回城坐标;

		public static string 监狱地图;

		public static int 坐牢善恶;

		public static int 坐牢善恶恢复间隔;

		public static int 坐牢恢复善恶值;

		public static string 坐牢杀人公告;

		public static string 刑满释放公告;

		public static int 武功防模式;

		public static int 属性扩展是否开启;

		public static int 上线属性提示开关;

		public static string 个人状态0;

		public static string 个人状态1;

		public static string 个人状态2;

		public static string 个人状态3;

		public static string 个人状态4;

		public static string 个人状态5;

		public static string 个人状态6;

		public static string 个人状态7;

		public static string 个人状态8;

		public static string 个人状态9;

		public static int 异口同声是否开启;

		public static int 异口同声开启小时;

		public static int 异口同声开启分;

		public static int 异口同声开启秒;

		public static 异口同声 ykts;

		public static double 异口同声经验;

		public static double 异口同声爆率;

		public static int 异口同声攻击;

		public static int 异口同声防御;

		public static int 异口同声血量;

		public static int 异口同声蓝值;

		public static int 异口同声气功;

		public static string 异口同声内容;

		public static int 异口同声活动是否开启;

		public static int 异口同声结束时间;

		public static int 是否开启五转;

		public static int 门甲组合消耗类型;

		public static int 门甲组合消耗的数量;

		public static int 金刚守护符和寒玉守护符相关配置;

		public static int 金刚和寒玉守护符失败掉等级;

		public static int 水晶符相关配置;

		public static int 水晶符失败掉等级;

		public static int 水晶符成功加等级;

		public static int 江湖快报强化阶段;

		public static int 是否开启江湖快报;

		public static string 江湖快报内容;

		public static int 强化全线提示颜色;

		public static string 江湖快报内容一属性;

		public static string 江湖快报内容二属性;

		public static string 江湖快报内容三属性;

		public static string 江湖快报内容四属性;

		public static double 强化一合成率;

		public static double 强化二合成率;

		public static double 强化三合成率;

		public static double 强化四合成率;

		public static double 强化五合成率;

		public static double 强化六合成率;

		public static double 强化七合成率;

		public static double 强化八合成率;

		public static double 强化九合成率;

		public static double 强化十合成率;

		public static double 属性阶段一合成率;

		public static double 属性阶段二合成率;

		public static double 属性阶段三合成率;

		public static double 属性阶段四合成率;

		public static double 属性阶段五合成率;

		public static double 属性阶段六合成率;

		public static double 属性阶段七合成率;

		public static double 属性阶段八合成率;

		public static double 属性阶段九合成率;

		public static double 属性阶段十合成率;

		public static double 合成属性一合成率;

		public static double 合成属性二合成率;

		public static double 合成属性三合成率;

		public static double 合成属性四合成率;

		public static string 寄售元宝消费提示;

		public static int 元宝消费开启提示;

		public static string 元宝消费提示;

		public static int 积分消费开启提示;

		public static string 积分消费提示;

		public static string 防追杀所需物品ID;

		public static int 追踪玩家需要元宝数量;

		public static int 追杀系统是否开放;

		public static string 玩家追踪命令;

		public static int 特殊地图武勋倍数;

		public static string[] 特殊地图限制时间;

		public static string 特殊地图;

		public static string 杀人王奖励;

		public static Dictionary<int, 杀人提示> 杀人提示数据;

		public static int 杀人王数量;

		public static int 死亡播报次数;

		public static string 全服杀人提示;

		public static int 死亡全服公告是否开启;

		public static int 七彩提示是否开启;

		public static string 红色提示内容;

		public static string 赤色提示内容;

		public static string 橙色提示内容;

		public static string 绿色提示内容;

		public static string 蓝色提示内容;

		public static string 深蓝提示内容;

		public static string 紫色提示内容;

		public static string 七彩加属性;

		public static int 刷武勋BOSS开关;

		public static int 刷元宝BOSS开关;

		public static int 刷积分BOSS开关;

		public static int 刷金币BOSS开关;

		public static int 刷武勋BOSS开关1;

		public static int 刷元宝BOSS开关1;

		public static int 刷积分BOSS开关1;

		public static int 刷金币BOSS开关1;

		public static int 是否开启提示刷新BOSS坐标;

		public static int 是否开启世界随机BOSS一;

		public static int 是否开启世界随机BOSS二;

		public static int 删除BOSS时间一;

		public static int 删除BOSS时分一;

		public static int 删除BOSS时秒一;

		public static int 刷新BOSS时间一;

		public static int 刷新BOSS时分一;

		public static int 刷新BOSS时秒一;

		public static int 刷新BOSS怪物ID一;

		public static int 刷新BOSS怪物ID二;

		public static int 刷新BOSS怪物ID三;

		public static int 刷新BOSS怪物ID四;

		public static int 刷新BOSS所在地图ID一;

		public static string 刷新BOSS提示内容一;

		public static string 刷新BOSS提示内容二;

		public static string 刷新BOSS提示内容三;

		public static string 刷新BOSS提示内容四;

		public static int 删除BOSS时间二;

		public static int 删除BOSS时分二;

		public static int 删除BOSS时秒二;

		public static int 刷新BOSS时间二;

		public static int 刷新BOSS时分二;

		public static int 刷新BOSS时秒二;

		public static int 刷新BOSS怪物ID一二;

		public static int 刷新BOSS怪物ID二二;

		public static int 刷新BOSS怪物ID三二;

		public static int 刷新BOSS怪物ID四二;

		public static int 刷新BOSS所在地图ID二;

		public static string 刷新BOSS提示内容一二;

		public static string 刷新BOSS提示内容二二;

		public static string 刷新BOSS提示内容三二;

		public static string 刷新BOSS提示内容四二;

		public static string[] PK系统地图;

		public static string 获得胜利内容;

		public static Dictionary<int, 攻城数据> 攻城数据list;

		public static Dictionary<int, 门派成员> 门派成员list;

		public static Dictionary<int, 攻城战> 攻城战list;

		public static int 攻城战进程;

		public static 攻城Class 攻城;

		public static int 攻城战奖励类型;

		public static string 攻城战奖励属性;

		public static string 攻城战奖励物品;

		public static int 攻城战奖励套装;

		public static int 攻城战是否给增幅;

		public static string 攻城战增幅;

		public static string 攻城奖励地图;

		public static List<坐标Class> 攻城站区域;

		public static float 攻城战X坐标;

		public static float 攻城战Y坐标;

		public static int 攻城战范围;

		public static int 攻城战地图;

		public static int 攻城战开启小时;

		public static int 攻城战开启分;

		public static int 攻城战开启秒;

		public static int 攻城战是否开启;

		public static string[] 攻城战地图坐标;

		public static int 攻城时间;

		public static int 攻城奖励时间天数;

		public static int 城主药品时间;

		public static int 成员药品时间;

		public static string 成员提示内容;

		public static string 城主提示内容;

		public static int 攻城战状态;

		public static int 一阶转生副本需要元宝;

		public static int 一阶转生副本需要积分;

		public static int 一阶转生副本需要武勋;

		public static int 一阶转生副本需要金币;

		public static int 一阶转生副本是否开启;

		public static int 一阶转生副本转生限制;

		public static string 一阶转生副本移动命令;

		public static int 一阶转生副本地图ID;

		public static float 一阶转生副本地图坐标X;

		public static float 一阶转生副本地图坐标Y;

		public static int 二阶转生副本需要元宝;

		public static int 二阶转生副本需要积分;

		public static int 二阶转生副本需要武勋;

		public static int 二阶转生副本需要金币;

		public static int 二阶转生副本是否开启;

		public static int 二阶转生副本转生限制;

		public static string 二阶转生副本移动命令;

		public static int 二阶转生副本地图ID;

		public static float 二阶转生副本地图坐标X;

		public static float 二阶转生副本地图坐标Y;

		public static int 三阶转生副本需要元宝;

		public static int 三阶转生副本需要积分;

		public static int 三阶转生副本需要武勋;

		public static int 三阶转生副本需要金币;

		public static int 三阶转生副本是否开启;

		public static int 三阶转生副本转生限制;

		public static string 三阶转生副本移动命令;

		public static int 三阶转生副本地图ID;

		public static float 三阶转生副本地图坐标X;

		public static float 三阶转生副本地图坐标Y;

		public static Dictionary<int, 转生次数类> 转生次数数据;

		public static int 是否开启转生次数奖励;

		public static string 转生公告内容;

		public static int 转生公告;

		public static int 转生奖励套装;

		public static int 限制转生次数;

		public static int 转生需要等级;

		public static int 转生需要几转;

		public static int 转生降落几转;

		public static int 转生奖励类型;

		public static int 转生奖励数量;

		public static int 转生回落等级;

		public static string 转生获得属性;

		public static string 转生奖励物品;

		public static Dictionary<int, 等级奖励类> 等级奖励数据;

		public static int 转生次数领奖控制;

		public static int 是否开启等级奖励;

		public static int 活动副本状态;

		public static int 活动副本是否开启;

		public static int 活动副本等级限制;

		public static string 活动副本移动命令;

		public static int 活动副本地图ID;

		public static float 活动副本地图坐标X;

		public static float 活动副本地图坐标Y;

		public static int 活动副本开启小时;

		public static int 活动副本开启分;

		public static int 活动副本结束小时;

		public static int 活动副本结束分;

		public static string 活动副本开启公告内容;

		public static string 活动副本结束公告内容;

		public static int 活动副本需要元宝;

		public static int 活动副本需要积分;

		public static int 活动副本需要武勋;

		public static int 活动副本需要金币;

		public static long 人物最大元宝数;

		public static int 皇号福利每日次数;

		public static int 皇号福利开关;

		public static string 皇号福利命令;

		public static string 秘境副本移动命令;

		public static string 秘境挑战所需物品ID;

		public static int 秘境需要转生次数;

		public static int 秘境奖励类型;

		public static string 秘境奖励物品;

		public static string 秘境奖励属性;

		public static int 秘境开关;

		public static int 秘境每日次数;

		public static int 秘境人数;

		public static int 秘境限制等级;

		public static int 秘境重置时间;

		public static int 秘境重置时分;

		public static int 秘境准备时间;

		public static int 秘境第一波怪物数量;

		public static int 秘境第一波怪物时间;

		public static int 秘境第一波怪物ID;

		public static int 秘境第二波怪物数量;

		public static int 秘境第二波怪物时间;

		public static int 秘境第二波怪物ID;

		public static int 秘境第三波怪物数量;

		public static int 秘境第三波怪物时间;

		public static int 秘境第三波怪物ID;

		public static int 皇号福利重置时间;

		public static int 武勋保护等级;

		public static int 武勋保护数值;

		public static string 武勋保护命令;

		public static string 武勋保护删除命令;

		public static int 武勋保护需要元宝;

		public static double 忠诚度一阶段追加经验;

		public static double 忠诚度二阶段追加经验;

		public static double 忠诚度三阶段追加经验;

		public static double 忠诚度四阶段追加经验;

		public static double 宠物一转追加经验;

		public static double 宠物二转追加经验;

		public static double 宠物三转追加经验;

		public static double 宠物忠诚度一阶段经验调整;

		public static double 宠物忠诚度二阶段经验调整;

		public static double 宠物忠诚度三阶段经验调整;

		public static double 龙猫追加经验;

		public static double 羽雕追加经验;

		public static double 豹子追加经验;

		public static double 老虎追加经验;

		public static double 忠诚度满追加暴率;

		public static double 龙猫追加暴率;

		public static double 羽雕追加暴率;

		public static double 豹子追加暴率;

		public static double 老虎追加暴率;

		public static int 宠物掉忠诚间隔;

		public static int 宠物掉忠诚度数量;

		public static int 是否开启宠物加成;

		public static string[] 武功防额外调整;

		public static string[] 武功攻击额外调整;

		public static int 一阶段积分BUFF;

		public static int 一阶段积分增加防御;

		public static int 一阶段积分增加攻击;

		public static double 一阶段积分增加经验百分比;

		public static double 一阶段积分增加爆率百分比;

		public static double 一阶段积分增加合成强化百分比;

		public static int 一阶段积分增加蓝量;

		public static int 一阶段积分增加血量;

		public static int 二阶段积分BUFF;

		public static int 二阶段积分增加防御;

		public static int 二阶段积分增加攻击;

		public static double 二阶段积分增加经验百分比;

		public static double 二阶段积分增加爆率百分比;

		public static double 二阶段积分增加合成强化百分比;

		public static int 二阶段积分增加蓝量;

		public static int 二阶段积分增加血量;

		public static int 三阶段积分BUFF;

		public static int 三阶段积分增加防御;

		public static int 三阶段积分增加攻击;

		public static double 三阶段积分增加经验百分比;

		public static double 三阶段积分增加爆率百分比;

		public static double 三阶段积分增加合成强化百分比;

		public static int 三阶段积分增加蓝量;

		public static int 三阶段积分增加血量;

		public static int 四阶段积分BUFF;

		public static int 四阶段积分增加防御;

		public static int 四阶段积分增加攻击;

		public static double 四阶段积分增加经验百分比;

		public static double 四阶段积分增加爆率百分比;

		public static double 四阶段积分增加合成强化百分比;

		public static int 四阶段积分增加蓝量;

		public static int 四阶段积分增加血量;

		public static int 五阶段积分BUFF;

		public static int 五阶段积分增加防御;

		public static int 五阶段积分增加攻击;

		public static double 五阶段积分增加经验百分比;

		public static double 五阶段积分增加爆率百分比;

		public static double 五阶段积分增加合成强化百分比;

		public static int 五阶段积分增加蓝量;

		public static int 五阶段积分增加血量;

		public static int 积分BUFF是否开启;

		public static int 爱情度BUFF是否开启;

		public static int 爱情度一阶段;

		public static int 爱情度一阶段攻击增加;

		public static int 爱情度一阶段防御增加;

		public static int 爱情度一阶段血量增加;

		public static int 爱情度一阶段蓝值增加;

		public static double 爱情度一阶增加经验百分比;

		public static double 爱情度一阶增加爆率百分比;

		public static double 爱情度一阶增加合成强化百分比;

		public static int 爱情度二阶段;

		public static int 爱情度二阶段攻击增加;

		public static int 爱情度二阶段防御增加;

		public static int 爱情度二阶段血量增加;

		public static int 爱情度二阶段蓝值增加;

		public static double 爱情度二阶增加经验百分比;

		public static double 爱情度二阶增加爆率百分比;

		public static double 爱情度二阶增加合成强化百分比;

		public static int 爱情度三阶段;

		public static int 爱情度三阶段攻击增加;

		public static int 爱情度三阶段防御增加;

		public static int 爱情度三阶段血量增加;

		public static int 爱情度三阶段蓝值增加;

		public static double 爱情度三阶增加经验百分比;

		public static double 爱情度三阶增加爆率百分比;

		public static double 爱情度三阶增加合成强化百分比;

		public static int 爱情度四阶段;

		public static int 爱情度四阶段攻击增加;

		public static int 爱情度四阶段防御增加;

		public static int 爱情度四阶段血量增加;

		public static int 爱情度四阶段蓝值增加;

		public static double 爱情度四阶增加经验百分比;

		public static double 爱情度四阶增加爆率百分比;

		public static double 爱情度四阶增加合成强化百分比;

		public static int 爱情度五阶段;

		public static int 爱情度五阶段攻击增加;

		public static int 爱情度五阶段防御增加;

		public static int 爱情度五阶段血量增加;

		public static int 爱情度五阶段蓝值增加;

		public static double 爱情度五阶增加经验百分比;

		public static double 爱情度五阶增加爆率百分比;

		public static double 爱情度五阶增加合成强化百分比;

		public static double 妖花增加经验百分比;

		public static double 妖花增加概率百分比;

		public static int 妖花增加血量;

		public static double 妖花增加攻击力;

		public static double 妖花增加防御;

		public static double 妖花增加武功百分比;

		public static double 妖花增加武功防御百分比;

		public static int 新手上线奖励是否开启;

		public static string 新手上线奖励;

		public static int 北海武器气功加成;

		public static double 北海武器经验加成;

		public static int 攻击元宝BOSS一阶段奖励;

		public static int 攻击元宝BOSS一阶段伤害;

		public static int 攻击元宝BOSS二阶段奖励;

		public static int 攻击元宝BOSS二阶段伤害;

		public static int 攻击元宝BOSS三阶段奖励;

		public static int 攻击元宝BOSS三阶段伤害;

		public static int 攻击积分BOSS一阶段奖励;

		public static int 攻击积分BOSS一阶段伤害;

		public static int 攻击积分BOSS二阶段奖励;

		public static int 攻击积分BOSS二阶段伤害;

		public static int 攻击积分BOSS三阶段奖励;

		public static int 攻击积分BOSS三阶段伤害;

		public static int 攻击武勋BOSS一阶段奖励;

		public static int 攻击武勋BOSS一阶段伤害;

		public static int 攻击武勋BOSS二阶段奖励;

		public static int 攻击武勋BOSS二阶段伤害;

		public static int 攻击武勋BOSS三阶段奖励;

		public static int 攻击武勋BOSS三阶段伤害;

		public static int 攻击金币BOSS一阶段奖励;

		public static int 攻击金币BOSS一阶段伤害;

		public static int 攻击金币BOSS二阶段奖励;

		public static int 攻击金币BOSS二阶段伤害;

		public static int 攻击金币BOSS三阶段奖励;

		public static int 攻击金币BOSS三阶段伤害;

		public static string 耳环重造最高属性;

		public static int 耳环重造需要元宝数;

		public static int 耳环重造需要积分数;

		public static int 耳环重造需要武勋数;

		public static int 耳环重造需要金币数;

		public static string 戒指重造最高属性;

		public static int 戒指重造需要元宝数;

		public static int 戒指重造需要积分数;

		public static int 戒指重造需要武勋数;

		public static int 戒指重造需要金币数;

		public static string 项链重造最高属性;

		public static int 项链重造需要元宝数;

		public static int 项链重造需要积分数;

		public static int 项链重造需要武勋数;

		public static int 项链重造需要金币数;

		public static string 咕咕鸡重造最高属性;

		public static int 咕咕鸡最高攻击;

		public static int 咕咕鸡重造需要元宝数;

		public static int 咕咕鸡重造需要积分数;

		public static int 咕咕鸡重造需要武勋数;

		public static int 咕咕鸡重造需要金币数;

		public static string 老虎重造最高属性;

		public static int 老虎重造需要元宝数;

		public static int 老虎重造需要积分数;

		public static int 老虎重造需要武勋数;

		public static int 老虎重造需要金币数;

		public static string 龙猫重造最高属性;

		public static int 龙猫重造需要元宝数;

		public static int 龙猫重造需要积分数;

		public static int 龙猫重造需要武勋数;

		public static int 龙猫重造需要金币数;

		public static string 豹子重造最高属性;

		public static int 豹子重造需要元宝数;

		public static int 豹子重造需要积分数;

		public static int 豹子重造需要武勋数;

		public static int 豹子重造需要金币数;

		public static string 雪雕重造最高属性;

		public static int 雪雕重造需要元宝数;

		public static int 雪雕重造需要积分数;

		public static int 雪雕重造需要武勋数;

		public static int 雪雕重造需要金币数;

		public static int 是否开启宠物进阶;

		public static int 宠物进阶需要物品ID数量;

		public static int 宠物进阶需要物品ID;

		public static string 宠物进阶系统提示公告;

		public static int 宠物进阶高阶段;

		public static int 宠物进阶每一阶段增加攻击;

		public static int 宠物进阶每一阶段增加防御;

		public static int 宠物进阶每一阶段增加生命;

		public static int 宠物进阶每一阶段增加蓝值;

		public static int 进阶宠物元宝所需数量;

		public static int 进阶宠物积分所需数量;

		public static string 宠物进阶成功率;

		public static int 进阶宠物武勋所需数量;

		public static int 进阶宠物金币所需数量;

		public static int 是否开启项链进阶;

		public static int 项链进阶需要物品ID数量;

		public static int 项链进阶需要物品ID;

		public static string 项链进阶系统提示公告;

		public static int 项链进阶最高阶段;

		public static int 项链进阶每一阶段增加攻击;

		public static int 项链进阶每一阶段增加防御;

		public static int 项链进阶每一阶段增加生命;

		public static int 项链进阶每一阶段增加蓝值;

		public static int 进阶项链元宝所需数量;

		public static int 进阶项链积分所需数量;

		public static string 项链进阶成功率;

		public static int 进阶项链武勋所需数量;

		public static int 进阶项链金币所需数量;

		public static int 是否开启戒指进阶;

		public static int 戒指进阶需要物品ID数量;

		public static int 戒指进阶需要物品ID;

		public static string 戒指进阶系统提示公告;

		public static int 戒指进阶最高阶段;

		public static int 戒指进阶每一阶段增加攻击;

		public static int 戒指进阶每一阶段增加防御;

		public static int 戒指进阶每一阶段增加生命;

		public static int 戒指进阶每一阶段增加蓝值;

		public static int 进阶戒指元宝所需数量;

		public static int 进阶戒指积分所需数量;

		public static string 戒指进阶成功率;

		public static int 进阶戒指武勋所需数量;

		public static int 进阶戒指金币所需数量;

		public static int 是否开启耳环进阶;

		public static int 耳环进阶需要物品ID数量;

		public static int 耳环进阶需要物品ID;

		public static string 耳环进阶系统提示公告;

		public static int 耳环进阶最高阶段;

		public static int 耳环进阶每一阶段增加攻击;

		public static int 耳环进阶每一阶段增加防御;

		public static int 耳环进阶每一阶段增加生命;

		public static int 耳环进阶每一阶段增加蓝值;

		public static int 进阶耳环元宝所需数量;

		public static int 进阶耳环积分所需数量;

		public static string 耳环进阶成功率;

		public static int 进阶耳环武勋所需数量;

		public static int 进阶耳环金币所需数量;

		public static int 是否开启披风进阶;

		public static int 披风强化需要物品ID数量;

		public static int 披风强化需要物品ID;

		public static string 披风强化系统提示公告;

		public static int 披风强化最高阶段;

		public static int 披风强化每一阶段增加攻击;

		public static int 披风强化每一阶段增加防御;

		public static int 披风强化每一阶段增加生命;

		public static int 披风强化每一阶段增加蓝值;

		public static double 披风强化每一阶段增加经验值;

		public static int 进阶披风元宝所需数量;

		public static int 进阶披风积分所需数量;

		public static string 披风进阶成功率;

		public static int 进阶披风武勋所需数量;

		public static int 进阶披风金币所需数量;

		public static int 是否开启武器强化;

		public static int 武器强化需要物品ID数量;

		public static int 武器强化需要物品ID;

		public static string 武器强化系统提示公告;

		public static int 武器强化最高等级;

		public static int 武器强化每一阶段增加攻击;

		public static int 武器强化每一阶段增加防御;

		public static int 武器强化每一阶段增加生命;

		public static int 武器强化每一阶段增加蓝值;

		public static int 强化武器元宝所需数量;

		public static int 强化武器积分所需数量;

		public static string 武器强化成功率;

		public static int 强化武器武勋所需数量;

		public static int 强化武器金币所需数量;

		public static int 是否开启门甲升级;

		public static int 门甲升级需要物品ID数量;

		public static int 门甲升级需要物品ID;

		public static string 门甲升级系统提示公告;

		public static int 门甲升级元宝所需数量;

		public static string 门甲升级成功率;

		public static string 升级门甲所需物品ID;

		public static int 门甲升级金币所需数量;

		public static int 是否开启防具强化;

		public static int 防具强化需要物品ID数量;

		public static int 防具强化需要物品ID;

		public static string 防具强化系统提示公告;

		public static int 防具强化最高等级;

		public static int 防具强化每一阶段增加攻击;

		public static int 防具强化每一阶段增加防御;

		public static int 防具强化每一阶段增加生命;

		public static int 防具强化每一阶段增加蓝值;

		public static int 强化防具元宝所需数量;

		public static int 强化防具积分所需数量;

		public static string 防具强化成功率;

		public static int 强化防具武勋所需数量;

		public static int 强化防具金币所需数量;

		public static StarClass 幸运奖;

		public static double 幸运奖倒计时间1;

		public static double 幸运奖倒计时间2;

		public static string 幸运奖奖励;

		public static int 幸运奖开启分;

		public static int 幸运奖开启秒;

		public static int 幸运奖开启小时;

		public static string 幸运奖配置;

		public static int 幸运奖是否开启;

		public static string 购买彩票命令;

		public static int 彩票是否开启;

		public static int 购买彩票下注类型;

		public static int 彩票开启小时;

		public static int 彩票开启分;

		public static int 彩票开启秒;

		public static int 彩票下注最小数;

		public static int 彩票下注最大数;

		public static int 彩票中一个倍数;

		public static int 彩票中两个倍数;

		public static int 彩票全中倍数;

		public static int 彩票中特别倍数;

		public static string 彩票开奖内容;

		public static string 时时彩命令;

		public static int 是否开启随机号码;

		public static int 时时彩倒计时;

		public static int 时时彩是否开启;

		public static int 时时彩下注类型;

		public static int 时时彩全中倍数;

		public static int 时时彩中两个倍数;

		public static int 时时彩中一个倍数;

		public static int 时时彩下注最小数;

		public static int 时时彩下注最大数;

		public static string 时时彩开奖内容;

		public static string 时时彩开启号码;

		public static 时时彩系统 shishicai;

		public static string 打劫命令;

		public static int 是否开启打劫系统;

		public static int 打劫成功获得元宝;

		public static int 打劫成功获得积分;

		public static int 打劫成功获得武勋;

		public static int 打劫成功机率;

		public static int 打劫间隔时间;

		public static int 打劫失败扣除元宝;

		public static int 打劫失败扣除积分;

		public static int 打劫失败扣除武勋;

		public static int 打劫元宝所需数量;

		public static int 打劫积分所需数量;

		public static int 打劫武勋所需数量;

		public static int 是否开启打劫类型;

		public static 骰子系统 骰子;

		public static string 骰子参与元宝公告内容;

		public static string 骰子参与积分公告内容;

		public static string 骰子参与武勋公告内容;

		public static double 骰子豹子奖励倍数;

		public static double 骰子大小奖励倍数;

		public static double 骰子点数奖励倍数;

		public static double 骰子公告间隔时间;

		public static int 骰子功能是否开启;

		public static int 是否开启赌博类型;

		public static double 骰子开奖倒计时间1;

		public static double 骰子开奖倒计时间2;

		public static string 骰子开启公告内容;

		public static int 骰子控制结束时间;

		public static int 骰子控制开始时间;

		public static string 骰子配置;

		public static string 骰子提示设置;

		public static int 骰子最大下注额;

		public static int 骰子最小下注额;

		public static int 作假下注额;

		public static int 是否开启重复下注处罚;

		public static 科举系统 科举;

		public static Dictionary<int, 科举系统类> 科举出题;

		public static Dictionary<int, 科举系统类2> 科举出题2;

		public static Dictionary<int, 科举系统类3> 科举出题3;

		public static Dictionary<int, 科举系统类4> 科举出题4;

		public static Dictionary<int, 科举系统类5> 科举出题5;

		public static Dictionary<int, 科举系统类6> 科举出题6;

		public static Dictionary<int, 科举系统类7> 科举出题7;

		public static int 科举答题回答时间;

		public static int 科举答题间隔时间;

		public static double 科举倒计时间1;

		public static double 科举倒计时间2;

		public static double 科举公告间隔时间;

		public static int 科举奖励第一名奖元宝;

		public static int 科举奖励第一名奖积分;

		public static int 科举奖励第一名奖武勋;

		public static int 科举奖励类型;

		public static int 科举考试奖励类型;

		public static int 科举开启分;

		public static int 科举开启秒;

		public static int 科举开启时;

		public static string 科举配置;

		public static int 科举是否开启;

		public static string 科举提示设置;

		public static int 改变职业元宝数;

		public static int 改变职业积分数;

		public static int 改变职业武勋数;

		public static int 改变职业金币数;

		public static int 改变职业所需转职等级;

		public static int 是否开启改变职业;

		public static int 转换正邪是否开启;

		public static int 转换正邪需要元宝;

		public static int 转换正邪需要积分;

		public static int 转换正邪需要武勋;

		public static int 转换正邪需要金币;

		public static int 转换正邪所需转职等级;

		public static int 四武器封顶属性;

		public static int 七武器封顶属性;

		public static int 十武器封顶属性;

		public static int 十三武器封顶属性;

		public static int 武勋防具封顶属性;

		public static int 万能卡重造属性需要元宝数;

		public static int 万能卡重造属性需要积分数;

		public static int 万能卡重造属性需要武勋数;

		public static int 万能卡重造属性需要金币数;

		public static string 进阶成功率;

		public static int 装备使用万能卡后是否绑定;

		public static string 回收几的武器;

		public static double 武勋阶段一需要;

		public static double 武勋阶段二需要;

		public static double 武勋阶段三需要;

		public static double 武勋阶段四需要;

		public static double 武勋阶段五需要;

		public static double 武勋阶段六需要;

		public static double 武勋阶段七需要;

		public static double 武勋阶段八需要;

		public static double 武勋阶段九需要;

		public static int 武勋值扩展属性开关;

		public static int 武勋值扩展属性数值;

		public static int 武勋值扩展属性攻击增加;

		public static int 武勋值扩展属性防御增加;

		public static int 武勋值扩展属性生命增加;

		public static int 武勋值扩展属性蓝值增加;

		public static int 武勋值扩展属性气功增加;

		public static double 武勋值扩展属性经验百分比;

		public static double 武勋值扩展属性金钱百分比;

		public static double 武勋值扩展属性历练百分比;

		public static double 武勋值扩展属性爆率百分比;

		public static string[] 武勋阶段1;

		public static string[] 武勋阶段2;

		public static string[] 武勋阶段3;

		public static string[] 武勋阶段4;

		public static string[] 武勋阶段5;

		public static string[] 武勋阶段6;

		public static string[] 武勋阶段7;

		public static string[] 武勋阶段8;

		public static string[] 武勋阶段9;

		public static int 监控开店购买记录;

		public static int 是否开启综合商店;

		public static int BOSS不受越级检测开关;

		public static string BOSS怪随机掉落物品数量;

		public static int 百宝送积分是否开启;

		public static double 怪物防御百分比;

		public static double 怪物攻击下降倍数;

		public static double 怪物暴击伤害百分比;

		public static double 出售物品百分比;

		public static double 金符出售物品百分比;

		public static int 怪物死亡触发器;

		public static int 是否开启高倍经验开关;

		public static long 会员最高等级;

		public static string 升级会员需要属性;

		public static int 物品兑换LUA脚本是否开启;

		public static double 历练获得降低百分比;

		public static double 经验获得降低百分比;

		public static int 物品属性大小;

		public static string 门派升级命令;

		public static int 二级门派升级所需元宝;

		public static int 二级门派升级所需金钱;

		public static int 二级门派升级所需积分;

		public static int 二级门派升级所需武勋;

		public static int 二级门派升级所需声望;

		public static int 三级门派升级所需元宝;

		public static int 三级门派升级所需金钱;

		public static int 三级门派升级所需积分;

		public static int 三级门派升级所需武勋;

		public static int 三级门派升级所需声望;

		public static int 四级门派升级所需元宝;

		public static int 四级门派升级所需金钱;

		public static int 四级门派升级所需积分;

		public static int 四级门派升级所需武勋;

		public static int 四级门派升级所需声望;

		public static int 五级门派升级所需元宝;

		public static int 五级门派升级所需金钱;

		public static int 五级门派升级所需积分;

		public static int 五级门派升级所需武勋;

		public static int 五级门派升级所需声望;

		public static int 六级门派升级所需元宝;

		public static int 六级门派升级所需金钱;

		public static int 六级门派升级所需积分;

		public static int 六级门派升级所需武勋;

		public static int 六级门派升级所需声望;

		public static double 二级门派增加经验;

		public static double 二级门派增加爆率;

		public static double 三级门派增加经验;

		public static double 三级门派增加爆率;

		public static double 四级门派增加经验;

		public static double 四级门派增加爆率;

		public static double 五级门派增加经验;

		public static double 五级门派增加爆率;

		public static double 六级门派增加经验;

		public static double 六级门派增加爆率;

		public static int 兑换武勋是否开启;

		public static int 需要本身武勋数;

		public static int 兑换武勋需要数量;

		public static string 组队经验加成;

		public static int 刀客数量;

		public static int 剑客数量;

		public static int 枪客数量;

		public static int 医生数量;

		public static int 弓箭手数量;

		public static double 刀客经验减少;

		public static double 剑客经验减少;

		public static double 枪客经验减少;

		public static double 医生经验减少;

		public static double 弓箭手经验减少;

		public static string 离线挂机打怪命令;

		public static int 离线打怪GS监控;

		public static int 离线打怪位置;

		public static DateTime 离线挂机时间间隔;

		public static DateTime 离线挂机轻功间隔;

		public static int 离线挂机喊话间隔;

		public static int 全队521开关;

		public static int 群医范围;

		public static int 群医加经验爆率开关;

		public static double 群医加经验百分比;

		public static double 群医加爆率百分比;

		public static Dictionary<string, LuandouTopClass> LuandouTop;

		public static Dictionary<int, 乱斗排名类> 乱斗排名数据;

		public static Dictionary<int, 段位提示> 段位提示数据;

		public static List<坐标Class> 乱斗地区;

		public static 无限乱斗 Luandou;

		public static int 乱斗进程;

		public static int 乱斗系统是否开启;

		public static int 乱斗奖励是否开启;

		public static int 乱斗地图;

		public static float 乱斗地区X坐标;

		public static float 乱斗地区Y坐标;

		public static int 乱斗地区范围;

		public static int 乱斗倒计时;

		public static int 乱斗战斗时间;

		public static string 乱斗命令;

		public static string 累计击杀奖励1;

		public static string 累计击杀奖励2;

		public static string 累计击杀奖励3;

		public static string 累计击杀奖励4;

		public static int 抽奖消耗元宝;

		public static int 抽奖是否返积分;

		public static double 抽奖返积分比例;

		public static int 乱斗开启时;

		public static int 乱斗开启分;

		public static int 乱斗开启秒;

		public static int ver;

		public static int 核查掉线秒;

		public static double ServerVer;

		public static double ServerVerD;

		public static string ServerRegTime;

		public static bool Droplog;

		public static string Key;

		public static string Key2;

		public static AtapiDevice Keyk;

		public static int AllItmelog;

		public static bool AlWorldlog;

		public static bool Process;

		public static bool 线程同步变量;

		public static int ServerIDStart;

		public static int 宣战进程;

		public static int 复仇进程;

		public static EvePVPClass 宣战;

		public static EveFCClass 复仇;

		public static ThreadSafeDictionary<int, Players> eve90Players;

		public static ThreadSafeDictionary<int, Players> eve80Players;

		public static Dictionary<string, 冲关地图类> 冲关地图list;

		public static Dictionary<int, 石头属性调整类> 石头属性调整;

		public static ThreadSafeDictionary<int, NetState> list;

		public static Dictionary<string, EventTopClass> EventTop;

		public static ThreadSafeDictionary<int, Players> allConnectedChars;

		public static Dictionary<int, 任务类> 任务list;

		public static Dictionary<string, DbClass> Db;

		public static Queue m_Disposed;

		public static Queue SqlPool;

		public static Dictionary<int, double> lever;

		public static Dictionary<int, double> Patlever;

		public static Dictionary<int, 公告类> 公告;

		public static ThreadSafeDictionary<long, 地面物品类> ItmeTeM;

		public static Dictionary<int, MapClass> Map;

		public static Dictionary<int, MonSterClss> MonSter;

		public static Dictionary<int, ItmeClass> Itme;

		public static Dictionary<int, 武功类> TBL_KONGFU;

		public static Dictionary<int, 组队Class> W组队;

		public static Dictionary<int, 帮战Class> 帮战list;

		public static List<ShotClass> Shot;

		public static List<检查物品类> 物品检查;

		public static List<KillClass> Kill;

		public static List<DropClass> Drop;

		public static List<DropClass> Drop_GS;

		public static List<DropClass> BossDrop;

		public static List<OpenClass> Open;

		public static List<MoveClass> Mover;

		public static List<坐标Class> 移动;

		public static List<坐标Class> 排位地区;

		public static List<转职属性类> 转职属性;

		public static List<int> lockLevel;

		public static Dictionary<int, 安全区Class> 安全区;

		public static List<坐标Class> 对练区;

		public static List<坐标Class> 复仇区;

		public static Dictionary<string, string> 势力战掉线玩家;

		public static Dictionary<int, List<string>> 势力战玩家列表;

		public static Dictionary<int, bbg物品类> 百宝阁物品;

		public static Dictionary<int, 套装物品类> 套装物品;

		public static Dictionary<int, 会员装备类> 会员物品;

		public static Dictionary<int, 套装物品类> 冲级奖励物品;

		public static Dictionary<int, 任务系统> 任务公告list;

		public static Dictionary<int, 任务需要物品> 任务需要物品list;

		public static Dictionary<int, BOSS地图> BOSS设置list;

		public static Dictionary<int, 假人坐标> 假人;

		public static Dictionary<int, 假人喊话> 假人hanhua;

		public static int 单个物品大小;

		public static object locklist2;

		public static object lockLogin;

		public static List<object> locklist3;

		public static List<object> lockDrop;

		public static int 游戏登陆端口最大连接数;

		public static int 游戏登陆端口最大连接时间数;

		public static int 查非法物品;

		public static int 查非法物品操作;

		public static bool 查绑定非法物品;

		public static int 物品最高攻击值;

		public static int 物品最高防御值;

		public static int 物品最高武功值;

		public static int 物品最高武防值;

		public static int 物品记录;

		public static int 登陆记录;

		public static int PK记录;

		public static int 记录保存天数;

		public static bool 封IP;

		public static List<IPAddress> BipList;

		public static int 自动连接时间;

		public static int 版本验证时间;

		public static bool 主Socket;

		public static string SocketState;

		public static bool 自动开启换端口;

		public static int 允许最大连接数;

		public static bool 断开连接;

		public static bool 加入过滤列表;

		public static bool 关闭连接;

		public static EventClass eve;

		public static int 组队获得经验限制;

		public static int W组队Id;

		public static int tf;

		public static int jlMsg;

		public static int 允许交易等级;

		public static int 允许交易披风;

		public static int 是否允许开店;

		public static double 寄售获得元宝比例;

		public static int 寄售系统是否开启;

		public static int 是否可以寄售绑定装备;

		public static int 是否限制加速器;

		public static int 是否开启门派正邪;

		public static int 是否校验机器码;

		public static int 限制加速器时间;

		public static int 加速检查次数;

		public static int 外挂锁人时间;

		public static int 外挂检测操作;

		public static int 窗口名检测模式;

		public static int 攻击加速检查次数;

		public static int 连续攻击有效时间;

		public static int 限制技能优化;

		public static int 武功连击有效时间;

		public static int 武功连击冷却时间;

		public static bool 封杀打坐杀怪;

		public static bool 封杀无限打坐卡技能;

		public static float[] 移动加速检查速度;

		public static int 移动加速检查次数;

		public static int 移动加速检查周期;

		public static string 老公提示内容;

		public static string 老婆提示内容;

		public static int 结婚物品ID;

		public static int 元宝商店购买间隔;

		public static string 夫妻经验爆率增加;

		public static 帮派战_门战 门战;

		public static int 门战是否开启;

		public static int 门战开启小时1;

		public static int 门战战开启分;

		public static int 门战战开启秒;

		public static int 门战限制等级;

		public static int 门战需要金币;

		public static int 门战地图;

		public static string 门站BOSS;

		public static int 门战进程;

		public static int 获胜门派获得武勋;

		public static int 失败门派获得武勋;

		public static string 门站随机奖励物品;

		public static 伏魔洞副本 副本;

		public static int 副本开始时间;

		public static int 副本结束时间;

		public static int 副本开启状态;

		public static int 副本进程;

		public static int 副本限制次数;

		public static int 势力战进程;

		public static int 几转势力战;

		public static int 势力战时间;

		public static int 势力战要求转职状态;

		public static int 势力战正分数;

		public static int 势力战邪分数;

		public static int 势力战第一滴血;

		public static int 组队获得经验范围;

		public static int 隔体传功是否开启;

		public static int 势力战是否开启;

		public static int 势力战时长;

		public static int 三转势力战开启小时;

		public static int 四转势力战开启小时;

		public static int 势力战开启分;

		public static int 势力战开启秒;

		public static int 势力战奖励类型;

		public static int 势力战奖励物品最大人数;

		public static string 势力战奖励个人物品;

		public static int 势力战限制进入时间;

		public static int[] 势力战奖励;

		public static int[] 势力战失败奖励;

		public static int 势力战参战等级;

		public static int 势力战随机奖励物品;

		public static int 势力战前五名奖励武勋;

		public static int 势力战五到十名奖励武勋;

		public static int 势力战十到二十名奖励武勋;

		public static int 势力战二十到五十名奖励武勋;

		public static int 势力战基础奖励武勋;

		public static int 假人上线初始武勋;

		public static string 挂机奖励;

		public static int 挂机奖励最大元宝;

		public static int 挂机奖励最大武勋;

		public static List<int> 挂机奖励地图;

		public static int 复制物品是否封号;

		public static int 复制物品检查时间;

		public static int 挂机奖励时间周期;

		public static int 离线挂机是否开启;

		public static double 离线挂机等级限制;

		public static int 新人保护等级;

		public static List<int> 不受保护符地图;

		public static int 创建门派需要等级;

		public static string 创建门派所需物品ID;

		public static double 气功百分比;

		public static int 最大气功数;

		public static int 最大钱数;

		public static int 最大元宝数;

		public static int 强化公告等级;

		public static int 元宝合成;

		public static int 装备加解锁开关;

		public static int 加锁元宝数;

		public static int 加锁金币数;

		public static int 解锁元宝数;

		public static int 解锁金币数;

		public static int 再造系统是否开启;

		public static int 每次消耗的数量;

		public static double 发送速度;

		public static double 广播发送速度;

		public static double 接收速度;

		public static double 经验倍数;

		public static int 获得经验等级差上线;

		public static int 获得经验等级差下线;

		public static double 钱倍数;

		public static double 历练倍数;

		public static int 暴率;

		public static string 百宝阁地址;

		public static string 百宝阁服务器IP;

		public static int 百宝阁服务器端口;

		public static int 高倍经验开启时间;

		public static int 高倍经验开启分间;

		public static int 高倍经验开启秒间;

		public static int 高倍经验结束时间;

		public static int 高倍经验结束分间;

		public static int 高倍经验结束秒间;

		public static double 高倍经验倍数;

		public static double 南明湖经验倍数;

		public static double 北海经验倍数;

		public static double 满职业经验增加;

		public static int 满职业经验增加是否开启;

		public static int 是否开启高倍经验;

		public static double 第一阶段经验倍数;

		public static double 第二阶段经验倍数;

		public static double 第三阶段经验倍数;

		public static double 第四阶段经验倍数;

		public static double 第五阶段经验倍数;

		public static double 第六阶段经验倍数;

		public static int 自定义等级一阶段;

		public static int 自定义等级二阶段;

		public static int 自定义等级三阶段;

		public static int 自定义等级四阶段;

		public static int 自定义等级五阶段;

		public static int 自定义等级六阶段;

		public static string 帐号验证服务器IP;

		public static int 帐号验证服务器端口;

		public static int 游戏服务器端口;

		public static int 游戏服务器端口2;

		public static int 游戏服务器端口1;

		public static int 转发器网关服务端口;

		public static int vip线;

		public static int 安全区开关;

		public static int 封包异步发送;

		public static int 最大在线;

		public static int 服务器组ID;

		public static int 服务器ID;

		public static string 服务器名;

		public static string 进入公告;

		public static int Gamedayov;

		public static string 进入传书;

		public static string 门派公告;

		public static BdAtapiDevice KeykF;

		public static int Log;

		public static int 验证服务器log;

		public static int 记录日志;

		public static int 狮子吼ID;

		public static Queue 狮子吼List;

		public static int 狮子吼最大数;

		public static ScriptClass 脚本;

		public static int 是否加密;

		public static int 登陆器模式;

		public static int 使用共享华夏登陆器;

		public static int PK开关;

		public static int 购买间隔;

		public static int 交易完成间隔;

		public static int 交易放物品间隔;

		public static Connect conn;

		public static string 冲关地图;

		public static string SqlJl;

		public static int 装备最大数;

		public static int 自动存档;

		public static List<int> 锁定物品列表;

		public static List<long> 查复制物品列表;

		public static string 地图锁定;

		public static string 金符地图;

		public static string 限制武勋地图;

		public static int 限制武勋地图数量;

		public static List<int> 限制PK地图列表;

		public static List<int> 限时PK地图列表;

		public static int 限时地图开PK时间;

		public static int 限时地图关PK时间;

		public static int 限时地图是否开启;

		public static int PK等级差;

		public static string[] dt;

		public static string[] fc;

		public static int 获得物品等级差上线;

		public static int 获得物品等级差下线;

		public static int 是否开启仓库时间限制;

		public static int 仓库操作间隔;

		public static string[] 综合仓库80级;

		public static int 综合仓库80级以下;

		public static int 换线收取类型;

		public static int 换线元宝数量;

		public static int 换线金币数量;

		public static int 伏魔洞收取类型;

		public static int 伏魔洞元宝数量;

		public static int 伏魔洞金币数量;

		public static string[] 杀人武勋限制;

		public static int 人物最高等级;

		public static int 经验珠最高等级;

		public static int 封印等级;

		public static double 武功防御力控制;

		public static double 武功攻击力控制;

		public static int 组队级别限制;

		public static int 武勋保护药品;

		public static int 武勋解保护药品;

		public static int 死亡保护药品;

		public static int 死亡保护时间;

		public static int 武器8阶段添加攻击;

		public static int 武器9阶段添加攻击;

		public static int 武器10阶段添加攻击;

		public static int 衣服8阶段添加防御;

		public static int 衣服9阶段添加防御;

		public static int 衣服10阶段添加防御;

		public static int 护手8阶段添加防御;

		public static int 护手9阶段添加防御;

		public static int 护手10阶段添加防御;

		public static int 鞋子8阶段添加防御;

		public static int 鞋子9阶段添加防御;

		public static int 鞋子10阶段添加防御;

		public static int 内甲8阶段添加防御;

		public static int 内甲9阶段添加防御;

		public static int 内甲10阶段添加防御;

		public static int 扔物品操作;

		public static int 医生弓手攻击距离;

		public static int 刀枪剑攻击距离;

		public static int 是否开启查看装备功能;

		public static int 是否开启师徒系统;

		public static int 徒弟最高等级限制;

		public static int 是否开启死亡掉经验;

		public static int 死亡复活锁定时间;

		public static int 死亡掉经验开始等级;

		public static int 死亡掉经验比例;

		public static int 是否上线发送礼品;

		public static int 新老玩家回归奖励;

		public static int 老玩家回归等级限制;

		public static int 上线礼品标识码;

		public static int 狮吼功需要元宝;

		public static int 狮吼功需要游戏币;

		public static int 狮吼功元宝金币切换开关;

		public static int 是否开启气功提示;

		public static int 是否开启跨线传音;

		public static int 是否开启共用银币市场;

		public static int 禁止出售物品1;

		public static int 禁止出售物品2;

		public static int 禁止出售物品3;

		public static int 禁止出售物品4;

		public static int 禁止出售物品5;

		public static double 刀客暴率百分比;

		public static double 刀打怪攻击百分比;

		public static double 刀打人攻击百分比;

		public static double 剑打怪攻击百分比;

		public static double 剑打人攻击百分比;

		public static double 枪打怪攻击百分比;

		public static double 枪打人攻击百分比;

		public static double 弓打怪攻击百分比;

		public static double 弓打人攻击百分比;

		public static double 医打人攻击百分比;

		public static double 医打怪攻击百分比;

		public static int 是否开启实时坐标显示;

		public static int 实时检测距离;

		public static double 限制打坐距离;

		public static float 普通走;

		public static float 轻功一;

		public static float 轻功二;

		public static float 轻功三;

		public static int 实时移动时间;

		public static float 宠物普通走;

		public static float 宠物轻功一;

		public static float 宠物轻功二;

		public static float 宠物轻功三;

		public static int 当前线路类型;

		public static int 退出时间间隔;

		public static int 换线存档方式;

		public static int 换线移动间隔;

		public static string 银币服务器IP;

		public static string 银币服务器IP2;

		public static string 银币服务器PORT;

		public static string 主服务器PORT;

		public static float 怪物移动最大范围;

		public static int 神珍大宝汤;

		public static bool 记录掉落;

		public static bool 记录再造;

		public static int 银币移动测试封包;

		public static int 限制远程打开NPC;

		public static int 打开NPC限制距离;

		public static int 开启限制武勋上限;

		public static long 吃武勋上限数值;

		public static int 是否限制无限躺尸;

		public static int 是否封杀锁人功能;

		public static int 周末全天PK是否开启;

		public static List<int> 周末全天PK地图列表;

		public static int 工作日限时地图开PK时间;

		public static int 工作日限时地图关PK时间;

		public static int 工作日限时地图是否开启;

		public static int 限制连环飞舞确认时间;

		public static int 连续快速攻击次数;

		public static int 非法攻击外挂操作;

		public static int 全局测试模式;

		public static int BOSS权限需要积分;

		public static int BOSS初始化次数;

		public static int BOSS金符持有初始化次数;

		public static int 是否开启BOSS挑战;

		public static int 合成小蓝猫开关;

		public static int 合成小蓝猫金币;

		public static int 合成小蓝猫元宝;

		public static int 合成小蓝猫碎片ID;

		public static int 合成小蓝猫I咕咕鸡碎片I数量;

		public static int 合成小蓝猫属性一;

		public static int 合成小蓝猫属性二;

		public static int 合成小蓝猫属性三;

		public static int 合成小蓝猫属性四;

		public static string 合成小蓝猫提示内容;

		public static string 无法合成小蓝猫提示内容;

		public static int 合成雪翼雕开关;

		public static int 合成雪翼雕金币;

		public static int 合成雪翼雕元宝;

		public static int 合成雪翼雕碎片ID;

		public static int 合成雪翼雕I龙猫碎片I数量;

		public static int 合成雪翼雕属性一;

		public static int 合成雪翼雕属性二;

		public static int 合成雪翼雕属性三;

		public static int 合成雪翼雕属性四;

		public static string 合成雪翼雕提示内容;

		public static string 无法合成雪翼雕提示内容;

		public static int 合成追风豹开关;

		public static int 合成追风豹金币;

		public static int 合成追风豹元宝;

		public static int 合成追风豹碎片ID;

		public static int 合成追风豹I雪翼雕碎片I数量;

		public static int 合成追风豹属性一;

		public static int 合成追风豹属性二;

		public static int 合成追风豹属性三;

		public static int 合成追风豹属性四;

		public static string 合成追风豹提示内容;

		public static string 无法合成追风豹提示内容;

		public static int 合成霸天虎开关;

		public static int 合成霸天虎金币;

		public static int 合成霸天虎元宝;

		public static int 合成霸天虎碎片ID;

		public static int 合成霸天虎I追风豹碎片I数量;

		public static int 合成霸天虎属性一;

		public static int 合成霸天虎属性二;

		public static int 合成霸天虎属性三;

		public static int 合成霸天虎属性四;

		public static string 合成霸天虎提示内容;

		public static string 无法合成霸天虎提示内容;

		public static int 分解咕咕鸡开关;

		public static int 分解咕咕鸡ID;

		public static int 分解咕咕鸡ID数量;

		public static string 分解咕咕鸡提示内容;

		public static string 无法分解咕咕鸡提示内容;

		public static int 分解龙猫开关;

		public static int 分解龙猫ID;

		public static int 分解龙猫ID数量;

		public static string 分解龙猫提示内容;

		public static string 无法分解龙猫提示内容;

		public static int 分解雪翼雕开关;

		public static int 分解雪翼雕ID;

		public static int 分解雪翼雕ID数量;

		public static string 分解雪翼雕提示内容;

		public static string 无法分解雪翼雕提示内容;

		public static int 分解追风豹开关;

		public static int 分解追风豹ID;

		public static int 分解追风豹ID数量;

		public static string 分解追风豹提示内容;

		public static string 无法分解追风豹提示内容;

		public static int 分解披风开关;

		public static int 分解披风ID;

		public static int 分解披风ID数量;

		public static string 分解披风提示内容;

		public static string 无法分解披风提示内容;

		public static int 吃金符是否送15符;

		public static int[] 掉线修复组队秒;

		public static string[] 掉线修复组队名字;

		public static int[] 掉线修复组队ID;

		public static int 世界时间事件累计秒;

		public static int 假人自动喊话开关;

		public static int 百宝物品禁止卖店;

		public static int 自动打开武勋状态;

		public static int 安全码开关;

		public static int 开启命令换线;

		public static int 开启NPC换线;

		public static int 泫勃派回城符永久使用;

		public static int 回城符单次扣除金币;

		public static int 功能监控;

		public static int 记录说话;

		public static int 快速攻击监测;

		public static int 自动组队功能开关;

		public static int BOOS总开关;

		public static int BOSS开启小时;

		public static int BOSS开启分钟;

		public static int BOSS开启秒;

		public static int BOSS存活秒;

		public static int BOSS第1名奖励物品ID;

		public static int BOSS第1名奖励物品ID2;

		public static int BOSS第2名奖励物品ID;

		public static int BOSS第2名奖励物品ID2;

		public static int BOSS第3名奖励物品ID;

		public static int BOSS第3名奖励物品ID2;

		public static int BOSS410名奖励物品ID;

		public static int BOSS1120名奖励物品ID;

		public static string BOSS开启公告;

		public static string BOSS结束公告;

		public static string BOSS开启命令;

		public static int BOSS倒计时秒;

		public static int BOSS进程秒;

		public static int BOSS世界ID;

		public static int BOSS血;

		public static int BOSS攻击;

		public static int BOSS防御;

		public static int BOSSPID;

		public static int BOSS的地图;

		public static int BOSS坐标X;

		public static int BOSS坐标Y;

		public static int 伤害排行1;

		public static int 伤害排行2;

		public static int 伤害排行3;

		public static int 伤害排行4;

		public static int 伤害排行5;

		public static int 伤害排行6;

		public static int 伤害排行7;

		public static int 伤害排行8;

		public static int 伤害排行9;

		public static int 伤害排行10;

		public static int 伤害排行11;

		public static int 伤害排行12;

		public static int 伤害排行13;

		public static int 伤害排行14;

		public static int 伤害排行15;

		public static int 伤害排行16;

		public static int 伤害排行17;

		public static int 伤害排行18;

		public static int 伤害排行19;

		public static int 伤害排行20;

		public static string 账号排行1;

		public static string 账号排行2;

		public static string 账号排行3;

		public static string 账号排行4;

		public static string 账号排行5;

		public static string 账号排行6;

		public static string 账号排行7;

		public static string 账号排行8;

		public static string 账号排行9;

		public static string 账号排行10;

		public static string 账号排行11;

		public static string 账号排行12;

		public static string 账号排行13;

		public static string 账号排行14;

		public static string 账号排行15;

		public static string 账号排行16;

		public static string 账号排行17;

		public static string 账号排行18;

		public static string 账号排行19;

		public static string 账号排行20;

		public static int 世界BOSS掉落元宝最小;

		public static int 世界BOSS掉落元宝最大;

		public static int 世界BOSS掉落武勋最小;

		public static int 世界BOSS掉落武勋最大;

		public static int 世界BOSS掉落金币最小;

		public static int 世界BOSS掉落金币最大;

		public static int 世界BOSS元宝爆率;

		public static int 世界BOSS武勋爆率;

		public static int 世界BOSS爆物品;

		public static int 世界BOSS金币爆率;

		public static int 世界BOSS物品爆率;

		public static int 世界BOSS最后一击奖励元宝;

		public static List<ServerClass> ServerList;

		public static string[] RanString;

		public static Dictionary<int, string> Maplist;

		public static Dictionary<int, NpcClass> NpcList;

		public static Players 检查玩家(string Userid)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				if (value.Userid == Userid)
				{
					return value;
				}
			}
			return null;
		}

		public static Players 检查玩家世界ID(int ID)
		{
			if (allConnectedChars.TryGetValue(ID, out Players value))
			{
				return value;
			}
			return null;
		}

		public static Players 检查玩家name(string Username)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				if (value.UserName == Username)
				{
					return value;
				}
			}
			return null;
		}

		public static void 发送公告(string msg)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统公告(msg);
			}
		}

		public static void 发送游戏特殊公告(string A_0, int A_1, string A_2)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统提示(A_0, A_1, A_2);
			}
		}

		public static void 系统滚动公告(string msg)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统滚动公告(msg);
			}
		}

		public static void 系统全局提示Sleep(string msg, string txt, int sleep)
		{
			Thread.Sleep(sleep);
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统提示(txt, 21, msg);
			}
		}

		public static void 系统全局提示(string msg, string txt, int type)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统提示(txt, type, msg);
			}
		}

		public static void 装逼全局提示(string msg, string txt, int type)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.装逼提示(txt, type, msg);
			}
		}

		public static void 全局提示(string msg, int type, string txt)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.系统提示(txt, type, msg);
			}
		}

		public static void Process狮子吼Queue()
		{
			if (狮子吼List.Count > 0)
			{
				if (jlMsg == 1)
				{
					Form1.WriteLine(1, "Process狮子吼Queue()");
				}
				狮子吼Class 狮子吼Class = (狮子吼Class)狮子吼List.Dequeue();
				发送狮子吼消息广播数据(狮子吼Class.FLD_INDEX, 狮子吼Class.UserName, 狮子吼Class.TxtId, 狮子吼Class.Txt);
			}
		}

		public static void 发送狮子吼消息广播数据(int 人物全服ID, string name, int msgid, string msg)
		{
			try
			{
				string hex = "AA55A6000000006600970000C8CEBDDC0000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055AA";
				byte[] array = Converter.hexStringToByte(hex);
				array[11] = 14;
				byte[] bytes = Encoding.Default.GetBytes(name);
				byte[] bytes2 = Encoding.Default.GetBytes(msg);
				Buffer.BlockCopy(bytes2, 0, array, 34, bytes2.Length);
				Buffer.BlockCopy(bytes, 0, array, 12, bytes.Length);
				Buffer.BlockCopy(BitConverter.GetBytes(人物全服ID), 0, array, 5, 2);
				array[33] = (byte)msgid;
				foreach (Players value in allConnectedChars.Values)
				{
					if (value.Client != null)
					{
						value.Client.Send(array, array.Length);
					}
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "World发送狮子吼消息广播数据出错![" + 人物全服ID.ToString() + "]-[" + name + "]-[" + msg + "]" + ex.Message);
			}
		}

		public static void 发送全服狮子吼消息广播数据(int 人物全服ID, string name, int msgid, string msg, int 线, int map)
		{
			try
			{
				string hex = "AA55A6000000006600970000C8CEBDDC0000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055AA";
				byte[] array = Converter.hexStringToByte(hex);
				array[11] = 14;
				byte[] bytes = Encoding.Default.GetBytes(name + " " + 线.ToString() + "线");
				byte[] bytes2 = Encoding.Default.GetBytes(msg);
				Buffer.BlockCopy(bytes2, 0, array, 34, bytes2.Length);
				Buffer.BlockCopy(bytes, 0, array, 12, bytes.Length);
				Buffer.BlockCopy(BitConverter.GetBytes(人物全服ID), 0, array, 5, 2);
				array[33] = (byte)msgid;
				foreach (Players value in allConnectedChars.Values)
				{
					if (value.Client != null)
					{
						value.Client.Send(array, array.Length);
					}
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "World发送狮子吼消息广播数据出错![" + 人物全服ID.ToString() + "]-[" + name + "]-[" + msg + "]" + ex.Message);
			}
		}

		public static void 发送帮派消息(string username, string msg, string bpname, int ServerID)
		{
			if (ServerID != 服务器ID)
			{
				_ = "[" + ServerID.ToString() + "线]" + username;
			}
			string hex = "AA55A6000000006600970000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055AA";
			byte[] array = Converter.hexStringToByte(hex);
			array[11] = 3;
			byte[] bytes = Encoding.Default.GetBytes(username);
			byte[] bytes2 = Encoding.Default.GetBytes(msg);
			Buffer.BlockCopy(bytes2, 0, array, 34, bytes2.Length);
			Buffer.BlockCopy(bytes, 0, array, 12, bytes.Length);
			Buffer.BlockCopy(BitConverter.GetBytes(300), 0, array, 5, 2);
			try
			{
				foreach (Players value in allConnectedChars.Values)
				{
					if (value.帮派名字 == bpname && value.Client != null)
					{
						value.Client.Send(array, array.Length);
					}
				}
			}
			catch
			{
			}
		}

		public static void 发送传音消息(int Wid, string FromName, string ToName, string msg)
		{
			try
			{
				Players players = 检查玩家name(ToName);
				if (players != null)
				{
					if (players.Config1.传音 == 0)
					{
						conn.发送("传音失败|对方设置不容许传音|" + Wid.ToString() + "|" + FromName);
					}
					else
					{
						conn.发送("传音返回|" + FromName + "|" + ToName + "|" + msg);
						string hex = "AA55A6000000006600970000C8CEBDDC0000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055AA";
						byte[] array = Converter.hexStringToByte(hex);
						array[11] = 4;
						byte[] bytes = Encoding.Default.GetBytes(FromName);
						byte[] bytes2 = Encoding.Default.GetBytes(msg);
						Buffer.BlockCopy(bytes2, 0, array, 34, bytes2.Length);
						Buffer.BlockCopy(bytes, 0, array, 12, bytes.Length);
						if (Wid == players.人物全服ID)
						{
							Wid++;
						}
						Buffer.BlockCopy(BitConverter.GetBytes(Wid), 0, array, 5, 2);
						if (players.Client != null)
						{
							players.Client.Send(array, array.Length);
						}
					}
				}
			}
			catch
			{
			}
		}

		public static void 发送传音返回消息(string FromName, string ToName, string msg)
		{
			try
			{
				Players players = 检查玩家name(FromName);
				if (players != null)
				{
					string hex = "AA55A6000000006600970000C8CEBDDC0000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055AA";
					byte[] array = Converter.hexStringToByte(hex);
					array[11] = 4;
					byte[] bytes = Encoding.Default.GetBytes(ToName);
					byte[] bytes2 = Encoding.Default.GetBytes(msg);
					Buffer.BlockCopy(bytes2, 0, array, 34, bytes2.Length);
					Buffer.BlockCopy(bytes, 0, array, 12, bytes.Length);
					Buffer.BlockCopy(BitConverter.GetBytes(players.人物全服ID), 0, array, 5, 2);
					if (players.Client != null)
					{
						players.Client.Send(array, array.Length);
					}
				}
			}
			catch
			{
			}
		}

		public static void 发送传音失败消息(string FromName, string msg)
		{
			try
			{
				检查玩家name(FromName)?.系统提示(msg, 9, "系统提示");
			}
			catch
			{
			}
		}

		public static int Add组队(组队Class 队)
		{
			int result = 1;
			for (int i = 1; i < 100000000; i++)
			{
				if (!W组队.TryGetValue(i, out 组队Class _))
				{
					W组队.Add(i, 队);
					result = i;
					break;
				}
			}
			return result;
		}

		static World()
		{
			红字标识 = 0;
			BOSS假人参与数 = 0;
			攻击模式 = 1;
			延迟死亡间隔 = 1500;
			假人上线获得装备模式 = 0;
			假人参与BOSS开关 = 0;
			假人气功开关 = 0;
			假人加入门派 = 0;
			假人获得武勋 = 0;
			假人接受组队 = 0;
			假人发呆提示 = 0;
			假人死亡提示 = 0;
			等级相差提示 = 0;
			假人自动结婚 = 0;
			假人打怪喊话 = 0;
			假人是否参加势力战 = 0;
			是否给假人开安全模式 = 0;
			全部假人安全模式 = 0;
			假人获得武勋计时器 = 0;
			假人死亡几次换位置 = 15;
			假人PK功能是否开启 = 1;
			是否给假人武器强化 = 0;
			假人自动转生 = 0;
			移动速度 = new string[8];
			走 = 15f;
			跑 = 35f;
			轻功15 = 45f;
			轻功60 = 85f;
			轻功100 = 140f;
			骑宠1 = 45f;
			骑宠2 = 55f;
			骑宠3 = 65f;
			物品数据 = 73;
			Set首爆石头 = new List<首爆石头>();
			Set首爆 = new List<首爆>();
			Sst自定义回收 = new List<自定义回收>();
			金刚石攻击 = 0L;
			金刚石命中 = 0L;
			金刚石生命 = 0L;
			金刚石武功 = 0L;
			金刚石气功 = 0L;
			金刚石追伤 = 0L;
			寒玉石防御 = 0L;
			寒玉石回避 = 0L;
			寒玉石内功 = 0L;
			寒玉石武防 = 0;
			寒玉石生命 = 0L;
			混元金刚石攻击 = 0L;
			混元金刚石气功 = 0L;
			混元金刚石命中 = 0L;
			混元金刚石生命 = 0L;
			混元金刚石武功 = 0L;
			混元金刚石追伤 = 0L;
			冰魄寒玉石防御 = 0L;
			冰魄寒玉石回避 = 0L;
			冰魄寒玉石内功 = 0L;
			冰魄寒玉石武防 = 0L;
			冰魄寒玉石生命 = 0L;
			热血石气功 = 0L;
			在线挂机打怪命令 = "!在线打怪";
			停止挂机打怪命令 = "!停止打怪";
			灵甲护身加成 = 1.25;
			创建门派需要金钱 = 0;
			全服土豪需要元宝 = 500;
			全服土豪需要积分 = 6000;
			队伍土豪需要金币 = 100000000;
			队伍土豪需要积分 = 1200;
			队伍土豪需要元宝 = 120;
			是否开启土豪系统 = 0;
			土豪经验金币数 = 1;
			土豪经验百分比 = 0.05;
			土豪爆率百分比 = 0.05;
			土豪经验持续时间 = 60000;
			队伍经验百分比 = 0.05;
			队伍爆率百分比 = 0.05;
			队伍经验持续时间 = 60000;
			门派经验金币数 = 1;
			门派经验积分数 = 1;
			门派经验元宝数 = 1;
			门派经验百分比 = 0.05;
			门派爆率百分比 = 0.05;
			门派经验持续时间 = 60000;
			武功防模式 = 0;
			异口同声是否开启 = 0;
			异口同声开启小时 = 0;
			异口同声开启分 = 0;
			异口同声开启秒 = 0;
			异口同声活动是否开启 = 0;
			异口同声结束时间 = 0;
			特殊地图武勋倍数 = 0;
			杀人提示数据 = new Dictionary<int, 杀人提示>();
			杀人王数量 = 100;
			死亡播报次数 = 0;
			死亡全服公告是否开启 = 0;
			获得胜利内容 = "尊贵的玩家上线了！大家欢迎！";
			攻城数据list = new Dictionary<int, 攻城数据>();
			门派成员list = new Dictionary<int, 门派成员>();
			攻城战list = new Dictionary<int, 攻城战>();
			攻城战进程 = 0;
			攻城站区域 = new List<坐标Class>();
			攻城战X坐标 = 500f;
			攻城战Y坐标 = 1550f;
			攻城战范围 = 101;
			攻城战地图 = 101;
			攻城战是否开启 = 0;
			攻城时间 = 30;
			攻城奖励时间天数 = 0;
			城主药品时间 = 0;
			成员药品时间 = 0;
			攻城战状态 = 0;
			转生次数数据 = new Dictionary<int, 转生次数类>();
			等级奖励数据 = new Dictionary<int, 等级奖励类>();
			皇号福利命令 = "";
			活动副本状态 = 0;
			活动副本移动命令 = "";
			活动副本开启公告内容 = "";
			活动副本结束公告内容 = "";
			武勋保护等级 = 35;
			武勋保护数值 = 1000;
			武勋保护命令 = "!开启武勋保护";
			武勋保护删除命令 = "!关闭武勋保护";
			宠物掉忠诚间隔 = 0;
			宠物掉忠诚度数量 = 0;
			是否开启宠物加成 = 0;
			爱情度BUFF是否开启 = 0;
			爱情度一阶段 = 0;
			爱情度一阶段攻击增加 = 0;
			爱情度一阶段防御增加 = 0;
			爱情度一阶段血量增加 = 0;
			爱情度一阶段蓝值增加 = 0;
			爱情度一阶增加经验百分比 = 0.0;
			爱情度一阶增加爆率百分比 = 0.0;
			爱情度一阶增加合成强化百分比 = 0.0;
			爱情度二阶段 = 0;
			爱情度二阶段攻击增加 = 0;
			爱情度二阶段防御增加 = 0;
			爱情度二阶段血量增加 = 0;
			爱情度二阶段蓝值增加 = 0;
			爱情度二阶增加经验百分比 = 0.0;
			爱情度二阶增加爆率百分比 = 0.0;
			爱情度二阶增加合成强化百分比 = 0.0;
			爱情度三阶段 = 0;
			爱情度三阶段攻击增加 = 0;
			爱情度三阶段防御增加 = 0;
			爱情度三阶段血量增加 = 0;
			爱情度三阶段蓝值增加 = 0;
			爱情度三阶增加经验百分比 = 0.0;
			爱情度三阶增加爆率百分比 = 0.0;
			爱情度三阶增加合成强化百分比 = 0.0;
			爱情度四阶段 = 0;
			爱情度四阶段攻击增加 = 0;
			爱情度四阶段防御增加 = 0;
			爱情度四阶段血量增加 = 0;
			爱情度四阶段蓝值增加 = 0;
			爱情度四阶增加经验百分比 = 0.0;
			爱情度四阶增加爆率百分比 = 0.0;
			爱情度四阶增加合成强化百分比 = 0.0;
			爱情度五阶段 = 0;
			爱情度五阶段攻击增加 = 0;
			爱情度五阶段防御增加 = 0;
			爱情度五阶段血量增加 = 0;
			爱情度五阶段蓝值增加 = 0;
			爱情度五阶增加经验百分比 = 0.0;
			爱情度五阶增加爆率百分比 = 0.0;
			爱情度五阶增加合成强化百分比 = 0.0;
			妖花增加经验百分比 = 0.0;
			妖花增加概率百分比 = 0.0;
			妖花增加血量 = 0;
			妖花增加攻击力 = 0.0;
			妖花增加防御 = 0.0;
			妖花增加武功百分比 = 0.0;
			妖花增加武功防御百分比 = 0.0;
			购买彩票命令 = "!购买彩票";
			彩票是否开启 = 0;
			购买彩票下注类型 = 0;
			彩票开启小时 = 0;
			彩票开启分 = 0;
			彩票开启秒 = 0;
			彩票中一个倍数 = 0;
			彩票中两个倍数 = 0;
			彩票全中倍数 = 0;
			彩票中特别倍数 = 0;
			时时彩命令 = "!时时彩";
			时时彩开奖内容 = "";
			打劫命令 = "!打劫";
			骰子参与元宝公告内容 = "玩家{0}参与了骰子！大家快参加吧！";
			骰子参与积分公告内容 = "玩家{0}参与了骰子！大家快参加吧！";
			骰子参与武勋公告内容 = "玩家{0}参与了骰子！大家快参加吧！";
			骰子豹子奖励倍数 = 0.0;
			骰子大小奖励倍数 = 0.0;
			骰子点数奖励倍数 = 0.0;
			骰子公告间隔时间 = 0.0;
			骰子功能是否开启 = 1;
			骰子开奖倒计时间1 = 0.0;
			骰子开奖倒计时间2 = 0.0;
			骰子开启公告内容 = "玩家{0}玩起了骰子！大家快参加吧！";
			骰子控制结束时间 = 0;
			骰子控制开始时间 = 0;
			骰子提示设置 = "系统提示";
			骰子最大下注额 = 0;
			骰子最小下注额 = 0;
			作假下注额 = 0;
			是否开启重复下注处罚 = 0;
			科举出题 = new Dictionary<int, 科举系统类>();
			科举出题2 = new Dictionary<int, 科举系统类2>();
			科举出题3 = new Dictionary<int, 科举系统类3>();
			科举出题4 = new Dictionary<int, 科举系统类4>();
			科举出题5 = new Dictionary<int, 科举系统类5>();
			科举出题6 = new Dictionary<int, 科举系统类6>();
			科举出题7 = new Dictionary<int, 科举系统类7>();
			科举答题回答时间 = 0;
			科举答题间隔时间 = 0;
			科举倒计时间1 = 0.0;
			科举倒计时间2 = 0.0;
			科举公告间隔时间 = 0.0;
			科举奖励第一名奖元宝 = 0;
			科举奖励第一名奖积分 = 0;
			科举奖励第一名奖武勋 = 0;
			科举奖励类型 = 0;
			科举考试奖励类型 = 0;
			科举开启分 = 0;
			科举开启秒 = 0;
			科举开启时 = 0;
			科举是否开启 = 0;
			科举提示设置 = "科举";
			是否开启改变职业 = 0;
			转换正邪是否开启 = 0;
			BOSS不受越级检测开关 = 0;
			怪物防御百分比 = 1.0;
			怪物攻击下降倍数 = 1.0;
			怪物暴击伤害百分比 = 1.0;
			怪物死亡触发器 = 0;
			是否开启高倍经验开关 = 0;
			物品兑换LUA脚本是否开启 = 0;
			历练获得降低百分比 = 0.0;
			经验获得降低百分比 = 0.0;
			物品属性大小 = 20;
			刀客经验减少 = 0.0;
			剑客经验减少 = 0.0;
			枪客经验减少 = 0.0;
			医生经验减少 = 0.0;
			弓箭手经验减少 = 0.0;
			任务list = new Dictionary<int, 任务类>();
			第一阶段经验倍数 = 0.0;
			第二阶段经验倍数 = 0.0;
			第三阶段经验倍数 = 0.0;
			第四阶段经验倍数 = 0.0;
			第五阶段经验倍数 = 0.0;
			第六阶段经验倍数 = 0.0;
			自定义等级一阶段 = 0;
			自定义等级二阶段 = 0;
			自定义等级三阶段 = 0;
			自定义等级四阶段 = 0;
			自定义等级五阶段 = 0;
			自定义等级六阶段 = 0;
			封印等级 = 0;
			离线挂机喊话间隔 = 30;
			全队521开关 = 0;
			LuandouTop = new Dictionary<string, LuandouTopClass>();
			ver = 0;
			核查掉线秒 = 0;
			ServerVer = 2.0;
			ServerVerD = 0.0;
			ServerRegTime = "";
			Droplog = false;
			Keyk = new AtapiDevice();
			AllItmelog = 1;
			AlWorldlog = true;
			Process = false;
			线程同步变量 = false;
			ServerIDStart = 0;
			宣战进程 = 0;
			复仇进程 = 0;
			eve90Players = new ThreadSafeDictionary<int, Players>();
			eve80Players = new ThreadSafeDictionary<int, Players>();
			冲关地图list = new Dictionary<string, 冲关地图类>();
			石头属性调整 = new Dictionary<int, 石头属性调整类>();
			list = new ThreadSafeDictionary<int, NetState>();
			EventTop = new Dictionary<string, EventTopClass>();
			allConnectedChars = new ThreadSafeDictionary<int, Players>();
			Db = new Dictionary<string, DbClass>();
			m_Disposed = Queue.Synchronized(new Queue());
			SqlPool = Queue.Synchronized(new Queue());
			Map = new Dictionary<int, MapClass>();
			帮战list = new Dictionary<int, 帮战Class>();
			安全区 = new Dictionary<int, 安全区Class>();
			对练区 = new List<坐标Class>();
			复仇区 = new List<坐标Class>();
			势力战掉线玩家 = new Dictionary<string, string>();
			势力战玩家列表 = new Dictionary<int, List<string>>();
			百宝阁物品 = new Dictionary<int, bbg物品类>();
			套装物品 = new Dictionary<int, 套装物品类>();
			会员物品 = new Dictionary<int, 会员装备类>();
			冲级奖励物品 = new Dictionary<int, 套装物品类>();
			任务公告list = new Dictionary<int, 任务系统>();
			任务需要物品list = new Dictionary<int, 任务需要物品>();
			BOSS设置list = new Dictionary<int, BOSS地图>();
			单个物品大小 = 36;
			locklist2 = new object();
			lockLogin = new object();
			locklist3 = new List<object>();
			lockDrop = new List<object>();
			游戏登陆端口最大连接数 = 20;
			游戏登陆端口最大连接时间数 = 1000;
			查非法物品 = 0;
			查非法物品操作 = 3;
			查绑定非法物品 = false;
			物品最高攻击值 = 61;
			物品最高防御值 = 49;
			物品最高武功值 = 51;
			物品最高武防值 = 80;
			物品记录 = 0;
			登陆记录 = 0;
			PK记录 = 1;
			记录保存天数 = 30;
			封IP = true;
			BipList = new List<IPAddress>();
			自动连接时间 = 10;
			版本验证时间 = 10000;
			主Socket = false;
			SocketState = "Stoped";
			自动开启换端口 = true;
			允许最大连接数 = 200;
			断开连接 = true;
			加入过滤列表 = true;
			关闭连接 = true;
			组队获得经验限制 = 700;
			W组队Id = 1;
			tf = 0;
			jlMsg = 0;
			允许交易等级 = 8;
			允许交易披风 = 1;
			是否允许开店 = 1;
			寄售获得元宝比例 = 0.9;
			寄售系统是否开启 = 0;
			是否可以寄售绑定装备 = 0;
			是否限制加速器 = 1;
			是否校验机器码 = 2;
			限制加速器时间 = 8000;
			加速检查次数 = 3;
			时间系统开关 = 1;
			世界时间 = 0;
			外挂锁人时间 = 20;
			外挂检测操作 = 0;
			窗口名检测模式 = 0;
			攻击加速检查次数 = 20;
			连续攻击有效时间 = 200;
			限制技能优化 = 1;
			武功连击有效时间 = 2500;
			武功连击冷却时间 = 8000;
			封杀打坐杀怪 = true;
			封杀无限打坐卡技能 = true;
			移动加速检查速度 = new float[10];
			移动加速检查次数 = 10;
			移动加速检查周期 = 2;
			门战是否开启 = 1;
			门战开启小时1 = 20;
			门战战开启分 = 0;
			门战战开启秒 = 0;
			门战限制等级 = 35;
			门战需要金币 = 100000000;
			门战地图 = 3001;
			门站BOSS = "";
			门战进程 = 0;
			获胜门派获得武勋 = 0;
			失败门派获得武勋 = 0;
			门站随机奖励物品 = "";
			副本开始时间 = 10;
			副本结束时间 = 22;
			副本开启状态 = 1;
			副本进程 = 0;
			副本限制次数 = 3;
			势力战进程 = 0;
			几转势力战 = 0;
			势力战时间 = 0;
			势力战要求转职状态 = 3;
			势力战正分数 = 0;
			势力战邪分数 = 0;
			势力战第一滴血 = 0;
			组队获得经验范围 = 250;
			隔体传功是否开启 = 0;
			势力战是否开启 = 0;
			势力战时长 = 0;
			三转势力战开启小时 = 0;
			四转势力战开启小时 = 0;
			势力战开启分 = 0;
			势力战开启秒 = 0;
			势力战奖励类型 = 0;
			势力战奖励物品最大人数 = 1;
			势力战奖励个人物品 = "";
			势力战限制进入时间 = 900;
			势力战奖励 = new int[10];
			势力战失败奖励 = new int[10];
			势力战参战等级 = 35;
			势力战随机奖励物品 = 9000165;
			势力战前五名奖励武勋 = 0;
			势力战五到十名奖励武勋 = 0;
			势力战十到二十名奖励武勋 = 0;
			势力战二十到五十名奖励武勋 = 0;
			势力战基础奖励武勋 = 0;
			假人上线初始武勋 = 0;
			复制物品是否封号 = 1;
			复制物品检查时间 = 20;
			挂机奖励时间周期 = 30;
			离线挂机是否开启 = 1;
			离线挂机等级限制 = 100.0;
			新人保护等级 = 35;
			创建门派需要等级 = 60;
			创建门派所需物品ID = "";
			气功百分比 = 1.0;
			最大气功数 = 0;
			最大钱数 = 2000000000;
			最大元宝数 = 1000000000;
			强化公告等级 = 9;
			元宝合成 = 5;
			装备加解锁开关 = 1;
			加锁元宝数 = 0;
			加锁金币数 = 10000000;
			解锁元宝数 = 0;
			解锁金币数 = 10000000;
			再造系统是否开启 = 1;
			发送速度 = 0.0;
			广播发送速度 = 0.0;
			接收速度 = 0.0;
			经验倍数 = 10.0;
			获得经验等级差上线 = 5;
			钱倍数 = 1.0;
			历练倍数 = 1.0;
			暴率 = 800;
			百宝阁地址 = "http://127.0.0.1:88/login.aspx?server=1";
			百宝阁服务器IP = "127.0.0.1";
			百宝阁服务器端口 = 9001;
			高倍经验开启时间 = 21;
			高倍经验开启分间 = 0;
			高倍经验开启秒间 = 0;
			高倍经验结束时间 = 22;
			高倍经验结束分间 = 0;
			高倍经验结束秒间 = 0;
			高倍经验倍数 = 1.5;
			南明湖经验倍数 = 1.5;
			北海经验倍数 = 1.5;
			满职业经验增加 = 1.5;
			是否开启高倍经验 = 0;
			帐号验证服务器IP = "127.0.0.1";
			帐号验证服务器端口 = 55970;
			游戏服务器端口 = 13001;
			游戏服务器端口2 = 13001;
			游戏服务器端口1 = 13001;
			转发器网关服务端口 = 50020;
			vip线 = 0;
			安全区开关 = 1;
			封包异步发送 = 0;
			最大在线 = 100;
			服务器组ID = 1;
			服务器ID = 0;
			服务器名 = "热血江湖";
			进入公告 = "欢迎光临!help查看自定义命令";
			Gamedayov = 0;
			进入传书 = "欢迎光临!help查看自定义命令";
			门派公告 = "万鑫江湖-长久稳定";
			KeykF = new BdAtapiDevice();
			狮子吼ID = 0;
			狮子吼List = Queue.Synchronized(new Queue());
			狮子吼最大数 = 0;
			是否加密 = 1;
			PK开关 = 0;
			购买间隔 = 500;
			交易完成间隔 = 500;
			交易放物品间隔 = 500;
			冲关地图 = "";
			SqlJl = "";
			装备最大数 = 36;
			自动存档 = 1;
			锁定物品列表 = new List<int>();
			查复制物品列表 = new List<long>();
			限制PK地图列表 = new List<int>();
			限时PK地图列表 = new List<int>();
			限时地图开PK时间 = 19;
			限时地图关PK时间 = 23;
			限时地图是否开启 = 0;
			PK等级差 = 15;
			是否开启仓库时间限制 = 10;
			仓库操作间隔 = 500;
			人物最高等级 = 255;
			经验珠最高等级 = 80;
			武功攻击力控制 = 100.0;
			组队级别限制 = 10;
			武勋保护药品 = 999000053;
			武勋解保护药品 = 1000000051;
			死亡保护药品 = 1000000052;
			死亡保护时间 = 8;
			扔物品操作 = 1;
			医生弓手攻击距离 = 100;
			刀枪剑攻击距离 = 50;
			是否开启查看装备功能 = 1;
			是否开启师徒系统 = 0;
			徒弟最高等级限制 = 80;
			是否开启死亡掉经验 = 1;
			死亡复活锁定时间 = 0;
			死亡掉经验开始等级 = 35;
			死亡掉经验比例 = 10000;
			是否上线发送礼品 = 0;
			新老玩家回归奖励 = 0;
			老玩家回归等级限制 = 59;
			上线礼品标识码 = 1;
			狮吼功需要元宝 = 10;
			狮吼功需要游戏币 = 10;
			是否开启气功提示 = 0;
			是否开启跨线传音 = 1;
			是否开启共用银币市场 = 1;
			禁止出售物品1 = 35;
			禁止出售物品2 = 35;
			禁止出售物品3 = 35;
			禁止出售物品4 = 35;
			禁止出售物品5 = 35;
			限制打坐距离 = 60.0;
			普通走 = 3.15f;
			轻功一 = 4.15f;
			轻功二 = 5.15f;
			轻功三 = 6.15f;
			实时移动时间 = 100;
			宠物普通走 = 3.15f;
			宠物轻功一 = 3.15f;
			宠物轻功二 = 3.15f;
			宠物轻功三 = 3.15f;
			当前线路类型 = 0;
			退出时间间隔 = 0;
			换线存档方式 = 1;
			换线移动间隔 = 5;
			银币服务器IP = "127.0.0.1";
			银币服务器IP2 = "127.0.0.1";
			银币服务器PORT = "0";
			主服务器PORT = "0";
			怪物移动最大范围 = 400f;
			记录掉落 = true;
			记录再造 = false;
			银币移动测试封包 = 0;
			限制远程打开NPC = 1;
			打开NPC限制距离 = 300;
			吃武勋上限数值 = 1000000L;
			是否限制无限躺尸 = 0;
			是否封杀锁人功能 = 1;
			周末全天PK是否开启 = 0;
			周末全天PK地图列表 = new List<int>();
			工作日限时地图开PK时间 = 5;
			工作日限时地图关PK时间 = 23;
			工作日限时地图是否开启 = 1;
			限制连环飞舞确认时间 = 45;
			连续快速攻击次数 = 10;
			非法攻击外挂操作 = 0;
			全局测试模式 = 1;
			BOSS权限需要积分 = 1500;
			BOSS初始化次数 = 0;
			BOSS金符持有初始化次数 = 1;
			是否开启BOSS挑战 = 0;
			掉线修复组队秒 = new int[1000];
			掉线修复组队名字 = new string[1000];
			掉线修复组队ID = new int[1000];
			世界时间事件累计秒 = 0;
			假人自动喊话开关 = 0;
			安全码开关 = 1;
			开启命令换线 = 0;
			开启NPC换线 = 0;
			泫勃派回城符永久使用 = 0;
			回城符单次扣除金币 = 0;
			记录说话 = 0;
			ServerList = new List<ServerClass>();
			RanString = new string[14]
			{
				"~",
				"/",
				"@",
				"#",
				"$",
				"%",
				"^",
				"&",
				"*",
				"|",
				"<",
				">",
				":",
				"`"
			};
			try
			{
				物品数据 = 73;
				离线打怪位置 = 0;
				离线挂机时间间隔 = DateTime.Now;
				离线挂机轻功间隔 = DateTime.Now;
				乱斗地图 = 2341;
				乱斗地区X坐标 = 0f;
				乱斗地区Y坐标 = 0f;
				乱斗倒计时 = 0;
				乱斗战斗时间 = 0;
				乱斗进程 = 0;
				乱斗排名数据 = new Dictionary<int, 乱斗排名类>();
				段位提示数据 = new Dictionary<int, 段位提示>();
				乱斗地区 = new List<坐标Class>();
				石头属性调整 = new Dictionary<int, 石头属性调整类>();
				eve90Players = new ThreadSafeDictionary<int, Players>();
				eve80Players = new ThreadSafeDictionary<int, Players>();
				转职属性 = new List<转职属性类>();
				Kill = new List<KillClass>();
				W组队 = new Dictionary<int, 组队Class>();
				公告 = new Dictionary<int, 公告类>();
				lever = new Dictionary<int, double>();
				Patlever = new Dictionary<int, double>();
				lockLevel = new List<int>();
				Itme = new Dictionary<int, ItmeClass>();
				ItmeTeM = new ThreadSafeDictionary<long, 地面物品类>();
				TBL_KONGFU = new Dictionary<int, 武功类>();
				MonSter = new Dictionary<int, MonSterClss>();
				假人 = new Dictionary<int, 假人坐标>();
				假人hanhua = new Dictionary<int, 假人喊话>();
				物品检查 = new List<检查物品类>();
				BossDrop = new List<DropClass>();
				Drop = new List<DropClass>();
				Drop_GS = new List<DropClass>();
				Open = new List<OpenClass>();
				Shot = new List<ShotClass>();
				Mover = new List<MoveClass>();
				移动 = new List<坐标Class>();
				对练区 = new List<坐标Class>();
				复仇区 = new List<坐标Class>();
				BOSS设置list = new Dictionary<int, BOSS地图>();
				挂机奖励地图 = new List<int>();
				Keyk.CpuID = Hasher.GetCpuID();
				Keyk.DriveID = Hasher.GetDriveID("C");
				Keyk.IP = Hasher.GetIP();
				Keyk.Mac = Hasher.GetMac();
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "系统错误:World" + ex?.ToString());
			}
		}

		public static void 更新副本次数()
		{
			try
			{
				RxjhClass.初始化副本次数();
				foreach (Players value in allConnectedChars.Values)
				{
					value.副本次数 = 0;
				}
			}
			catch (Exception)
			{
			}
		}

		public static void 发送地图PK公告(int msg)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				foreach (int item in 限时PK地图列表)
				{
					if (value.人物坐标_地图 == item)
					{
						if (msg == 1)
						{
							value.系统公告("本地图现在开始开放PK");
						}
						else
						{
							value.系统公告("本地图现在开始禁止PK");
						}
					}
				}
			}
		}

		private static int GetWeekName()
		{
			int result = 0;
			switch (DateTime.Now.DayOfWeek)
			{
			case DayOfWeek.Sunday:
				result = 7;
				break;
			case DayOfWeek.Monday:
				result = 1;
				break;
			case DayOfWeek.Tuesday:
				result = 2;
				break;
			case DayOfWeek.Wednesday:
				result = 3;
				break;
			case DayOfWeek.Thursday:
				result = 4;
				break;
			case DayOfWeek.Friday:
				result = 5;
				break;
			case DayOfWeek.Saturday:
				result = 6;
				break;
			}
			return result;
		}

		public static void 发送地图PK公告2(int msg)
		{
			foreach (Players value in allConnectedChars.Values)
			{
				foreach (int item in 限时PK地图列表)
				{
					if (value.人物坐标_地图 == item)
					{
						if (msg == 1)
						{
							value.系统公告("本地图现在开始开放PK");
						}
						else
						{
							value.系统公告("时间太晚了,为了广大玩家身心健康,本地图现在开始禁止PK");
						}
					}
				}
			}
		}

		private void 发奖励()
		{
			try
			{
				伤害排行1 = 0;
				伤害排行2 = 0;
				伤害排行3 = 0;
				伤害排行4 = 0;
				伤害排行5 = 0;
				伤害排行6 = 0;
				伤害排行7 = 0;
				伤害排行8 = 0;
				伤害排行9 = 0;
				伤害排行10 = 0;
				伤害排行11 = 0;
				伤害排行12 = 0;
				伤害排行13 = 0;
				伤害排行14 = 0;
				伤害排行15 = 0;
				伤害排行16 = 0;
				伤害排行17 = 0;
				伤害排行18 = 0;
				伤害排行19 = 0;
				伤害排行20 = 0;
				账号排行1 = "";
				账号排行2 = "";
				账号排行3 = "";
				账号排行4 = "";
				账号排行5 = "";
				账号排行6 = "";
				账号排行7 = "";
				账号排行8 = "";
				账号排行9 = "";
				账号排行10 = "";
				账号排行11 = "";
				账号排行12 = "";
				账号排行13 = "";
				账号排行14 = "";
				账号排行15 = "";
				账号排行16 = "";
				账号排行17 = "";
				账号排行18 = "";
				账号排行19 = "";
				账号排行20 = "";
				int num = 0;
				foreach (Players value in allConnectedChars.Values)
				{
					if (value.累计伤害 >= 1)
					{
						num++;
					}
				}
				foreach (Players value2 in allConnectedChars.Values)
				{
					value2.是否排行 = 0;
				}
				if (num >= 1)
				{
					全局提示("BOSS", 10, "本届 世界BOSS大战参加人数:" + num.ToString() + "人");
					int num2 = 0;
					for (num2 = 0; num2 < 21; num2++)
					{
						if (num2 == 1)
						{
							foreach (Players value3 in allConnectedChars.Values)
							{
								if (value3.累计伤害 >= 伤害排行1 && value3.累计伤害 > 0 && value3.是否排行 == 0)
								{
									伤害排行1 = value3.累计伤害;
									账号排行1 = value3.Userid;
								}
							}
							foreach (Players value4 in allConnectedChars.Values)
							{
								if (账号排行1 == value4.Userid)
								{
									value4.是否排行 = 1;
								}
							}
						}
						if (num2 == 2)
						{
							foreach (Players value5 in allConnectedChars.Values)
							{
								if (value5.累计伤害 >= 伤害排行2 && value5.累计伤害 > 0 && value5.是否排行 == 0)
								{
									伤害排行2 = value5.累计伤害;
									账号排行2 = value5.Userid;
								}
							}
							foreach (Players value6 in allConnectedChars.Values)
							{
								if (账号排行2 == value6.Userid)
								{
									value6.是否排行 = 1;
								}
							}
						}
						if (num2 == 3)
						{
							foreach (Players value7 in allConnectedChars.Values)
							{
								if (value7.累计伤害 >= 伤害排行3 && value7.累计伤害 > 0 && value7.是否排行 == 0)
								{
									伤害排行3 = value7.累计伤害;
									账号排行3 = value7.Userid;
								}
							}
							foreach (Players value8 in allConnectedChars.Values)
							{
								if (账号排行3 == value8.Userid)
								{
									value8.是否排行 = 1;
								}
							}
						}
						if (num2 == 4)
						{
							foreach (Players value9 in allConnectedChars.Values)
							{
								if (value9.累计伤害 >= 伤害排行4 && value9.累计伤害 > 0 && value9.是否排行 == 0)
								{
									伤害排行4 = value9.累计伤害;
									账号排行4 = value9.Userid;
								}
							}
							foreach (Players value10 in allConnectedChars.Values)
							{
								if (账号排行4 == value10.Userid)
								{
									value10.是否排行 = 1;
								}
							}
						}
						if (num2 == 5)
						{
							foreach (Players value11 in allConnectedChars.Values)
							{
								if (value11.累计伤害 >= 伤害排行5 && value11.累计伤害 > 0 && value11.是否排行 == 0)
								{
									伤害排行5 = value11.累计伤害;
									账号排行5 = value11.Userid;
								}
							}
							foreach (Players value12 in allConnectedChars.Values)
							{
								if (账号排行5 == value12.Userid)
								{
									value12.是否排行 = 1;
								}
							}
						}
						if (num2 == 6)
						{
							foreach (Players value13 in allConnectedChars.Values)
							{
								if (value13.累计伤害 >= 伤害排行6 && value13.累计伤害 > 0 && value13.是否排行 == 0)
								{
									伤害排行6 = value13.累计伤害;
									账号排行6 = value13.Userid;
								}
							}
							foreach (Players value14 in allConnectedChars.Values)
							{
								if (账号排行6 == value14.Userid)
								{
									value14.是否排行 = 1;
								}
							}
						}
						if (num2 == 7)
						{
							foreach (Players value15 in allConnectedChars.Values)
							{
								if (value15.累计伤害 >= 伤害排行7 && value15.累计伤害 > 0 && value15.是否排行 == 0)
								{
									伤害排行7 = value15.累计伤害;
									账号排行7 = value15.Userid;
								}
							}
							foreach (Players value16 in allConnectedChars.Values)
							{
								if (账号排行7 == value16.Userid)
								{
									value16.是否排行 = 1;
								}
							}
						}
						if (num2 == 8)
						{
							foreach (Players value17 in allConnectedChars.Values)
							{
								if (value17.累计伤害 >= 伤害排行8 && value17.累计伤害 > 0 && value17.是否排行 == 0)
								{
									伤害排行8 = value17.累计伤害;
									账号排行8 = value17.Userid;
								}
							}
							foreach (Players value18 in allConnectedChars.Values)
							{
								if (账号排行8 == value18.Userid)
								{
									value18.是否排行 = 1;
								}
							}
						}
						if (num2 == 9)
						{
							foreach (Players value19 in allConnectedChars.Values)
							{
								if (value19.累计伤害 >= 伤害排行9 && value19.累计伤害 > 0 && value19.是否排行 == 0)
								{
									伤害排行9 = value19.累计伤害;
									账号排行9 = value19.Userid;
								}
							}
							foreach (Players value20 in allConnectedChars.Values)
							{
								if (账号排行9 == value20.Userid)
								{
									value20.是否排行 = 1;
								}
							}
						}
						if (num2 == 10)
						{
							foreach (Players value21 in allConnectedChars.Values)
							{
								if (value21.累计伤害 >= 伤害排行10 && value21.累计伤害 > 0 && value21.是否排行 == 0)
								{
									伤害排行10 = value21.累计伤害;
									账号排行10 = value21.Userid;
								}
							}
							foreach (Players value22 in allConnectedChars.Values)
							{
								if (账号排行10 == value22.Userid)
								{
									value22.是否排行 = 1;
								}
							}
						}
						if (num2 == 11)
						{
							foreach (Players value23 in allConnectedChars.Values)
							{
								if (value23.累计伤害 >= 伤害排行11 && value23.累计伤害 > 0 && value23.是否排行 == 0)
								{
									伤害排行11 = value23.累计伤害;
									账号排行11 = value23.Userid;
								}
							}
							foreach (Players value24 in allConnectedChars.Values)
							{
								if (账号排行11 == value24.Userid)
								{
									value24.是否排行 = 1;
								}
							}
						}
						if (num2 == 12)
						{
							foreach (Players value25 in allConnectedChars.Values)
							{
								if (value25.累计伤害 >= 伤害排行12 && value25.累计伤害 > 0 && value25.是否排行 == 0)
								{
									伤害排行12 = value25.累计伤害;
									账号排行12 = value25.Userid;
								}
							}
							foreach (Players value26 in allConnectedChars.Values)
							{
								if (账号排行12 == value26.Userid)
								{
									value26.是否排行 = 1;
								}
							}
						}
						if (num2 == 13)
						{
							foreach (Players value27 in allConnectedChars.Values)
							{
								if (value27.累计伤害 >= 伤害排行13 && value27.累计伤害 > 0 && value27.是否排行 == 0)
								{
									伤害排行13 = value27.累计伤害;
									账号排行13 = value27.Userid;
								}
							}
							foreach (Players value28 in allConnectedChars.Values)
							{
								if (账号排行13 == value28.Userid)
								{
									value28.是否排行 = 1;
								}
							}
						}
						if (num2 == 14)
						{
							foreach (Players value29 in allConnectedChars.Values)
							{
								if (value29.累计伤害 >= 伤害排行14 && value29.累计伤害 > 0 && value29.是否排行 == 0)
								{
									伤害排行14 = value29.累计伤害;
									账号排行14 = value29.Userid;
								}
							}
							foreach (Players value30 in allConnectedChars.Values)
							{
								if (账号排行14 == value30.Userid)
								{
									value30.是否排行 = 1;
								}
							}
						}
						if (num2 == 15)
						{
							foreach (Players value31 in allConnectedChars.Values)
							{
								if (value31.累计伤害 >= 伤害排行15 && value31.累计伤害 > 0 && value31.是否排行 == 0)
								{
									伤害排行15 = value31.累计伤害;
									账号排行15 = value31.Userid;
								}
							}
							foreach (Players value32 in allConnectedChars.Values)
							{
								if (账号排行15 == value32.Userid)
								{
									value32.是否排行 = 1;
								}
							}
						}
						if (num2 == 16)
						{
							foreach (Players value33 in allConnectedChars.Values)
							{
								if (value33.累计伤害 >= 伤害排行16 && value33.累计伤害 > 0 && value33.是否排行 == 0)
								{
									伤害排行16 = value33.累计伤害;
									账号排行16 = value33.Userid;
								}
							}
							foreach (Players value34 in allConnectedChars.Values)
							{
								if (账号排行16 == value34.Userid)
								{
									value34.是否排行 = 1;
								}
							}
						}
						if (num2 == 17)
						{
							foreach (Players value35 in allConnectedChars.Values)
							{
								if (value35.累计伤害 >= 伤害排行17 && value35.累计伤害 > 0 && value35.是否排行 == 0)
								{
									伤害排行17 = value35.累计伤害;
									账号排行17 = value35.Userid;
								}
							}
							foreach (Players value36 in allConnectedChars.Values)
							{
								if (账号排行17 == value36.Userid)
								{
									value36.是否排行 = 1;
								}
							}
						}
						if (num2 == 18)
						{
							foreach (Players value37 in allConnectedChars.Values)
							{
								if (value37.累计伤害 >= 伤害排行18 && value37.累计伤害 > 0 && value37.是否排行 == 0)
								{
									伤害排行18 = value37.累计伤害;
									账号排行18 = value37.Userid;
								}
							}
							foreach (Players value38 in allConnectedChars.Values)
							{
								if (账号排行18 == value38.Userid)
								{
									value38.是否排行 = 1;
								}
							}
						}
						if (num2 == 19)
						{
							foreach (Players value39 in allConnectedChars.Values)
							{
								if (value39.累计伤害 >= 伤害排行19 && value39.累计伤害 > 0 && value39.是否排行 == 0)
								{
									伤害排行19 = value39.累计伤害;
									账号排行19 = value39.Userid;
								}
							}
							foreach (Players value40 in allConnectedChars.Values)
							{
								if (账号排行19 == value40.Userid)
								{
									value40.是否排行 = 1;
								}
							}
						}
						if (num2 == 20)
						{
							foreach (Players value41 in allConnectedChars.Values)
							{
								if (value41.累计伤害 >= 伤害排行20 && value41.累计伤害 > 0 && value41.是否排行 == 0)
								{
									伤害排行20 = value41.累计伤害;
									账号排行20 = value41.Userid;
								}
							}
							foreach (Players value42 in allConnectedChars.Values)
							{
								if (账号排行20 == value42.Userid)
								{
									value42.是否排行 = 1;
								}
							}
						}
					}
				}
				if (账号排行1.Length >= 1)
				{
					Players players = 检查玩家(账号排行1);
					if (players != null)
					{
						int num3 = players.得到包裹空位位置();
						if (num3 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players.UserName + "]赢得今日世界BOSS之战第一名");
							players.增加物品带属性(BOSS第1名奖励物品ID, num3, 1, 0, 0, 0, 0, 0, 0);
							players.增加物品带属性(BOSS第1名奖励物品ID2, num3, 1, 0, 0, 0, 0, 0, 0);
							players.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行2.Length >= 1)
				{
					Players players2 = 检查玩家(账号排行2);
					if (players2 != null)
					{
						int num4 = players2.得到包裹空位位置();
						if (num4 >= 0)
						{
							players2.增加物品带属性(BOSS第2名奖励物品ID, num4, 1, 0, 0, 0, 0, 0, 0);
							players2.增加物品带属性(BOSS第2名奖励物品ID2, num4, 1, 0, 0, 0, 0, 0, 0);
							全局提示("BOSS", 10, "恭喜玩家[" + players2.UserName + "]赢得今日世界BOSS之战第二名");
							players2.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players2.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行3.Length >= 1)
				{
					Players players3 = 检查玩家(账号排行3);
					if (players3 != null)
					{
						int num5 = players3.得到包裹空位位置();
						if (num5 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players3.UserName + "]赢得今日世界BOSS之战第三名");
							players3.增加物品带属性(BOSS第3名奖励物品ID, num5, 1, 0, 0, 0, 0, 0, 0);
							players3.增加物品带属性(BOSS第3名奖励物品ID2, num5, 1, 0, 0, 0, 0, 0, 0);
							players3.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players3.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行4.Length >= 1)
				{
					Players players4 = 检查玩家(账号排行4);
					if (players4 != null)
					{
						int num6 = players4.得到包裹空位位置();
						if (num6 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players4.UserName + "]赢得今日世界BOSS之战第4-10名");
							players4.增加物品带属性(BOSS410名奖励物品ID, num6, 1, 0, 0, 0, 0, 0, 0);
							players4.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players4.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行5.Length >= 1)
				{
					Players players5 = 检查玩家(账号排行5);
					if (players5 != null)
					{
						int num7 = players5.得到包裹空位位置();
						if (num7 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players5.UserName + "]赢得今日世界BOSS之战第4-10名");
							players5.增加物品带属性(BOSS410名奖励物品ID, num7, 1, 0, 0, 0, 0, 0, 0);
							players5.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players5.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行6.Length >= 1)
				{
					Players players6 = 检查玩家(账号排行6);
					if (players6 != null)
					{
						int num8 = players6.得到包裹空位位置();
						if (num8 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players6.UserName + "]赢得今日世界BOSS之战第4-10名");
							players6.增加物品带属性(BOSS410名奖励物品ID, num8, 1, 0, 0, 0, 0, 0, 0);
							players6.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players6.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行7.Length >= 1)
				{
					Players players7 = 检查玩家(账号排行7);
					if (players7 != null)
					{
						int num9 = players7.得到包裹空位位置();
						if (num9 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players7.UserName + "]赢得今日世界BOSS之战第4-10名");
							players7.增加物品带属性(BOSS410名奖励物品ID, num9, 1, 0, 0, 0, 0, 0, 0);
							players7.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players7.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行8.Length >= 1)
				{
					Players players8 = 检查玩家(账号排行8);
					if (players8 != null)
					{
						int num10 = players8.得到包裹空位位置();
						if (num10 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players8.UserName + "]赢得今日世界BOSS之战第4-10名");
							players8.增加物品带属性(BOSS410名奖励物品ID, num10, 1, 0, 0, 0, 0, 0, 0);
							players8.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players8.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行9.Length >= 1)
				{
					Players players9 = 检查玩家(账号排行9);
					if (players9 != null)
					{
						int num11 = players9.得到包裹空位位置();
						if (num11 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players9.UserName + "]赢得今日世界BOSS之战第4-10名");
							players9.增加物品带属性(BOSS410名奖励物品ID, num11, 1, 0, 0, 0, 0, 0, 0);
							players9.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players9.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行10.Length >= 1)
				{
					Players players10 = 检查玩家(账号排行10);
					if (players10 != null)
					{
						int num12 = players10.得到包裹空位位置();
						if (num12 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players10.UserName + "]赢得今日世界BOSS之战第4-10名");
							players10.增加物品带属性(BOSS410名奖励物品ID, num12, 1, 0, 0, 0, 0, 0, 0);
							players10.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players10.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行11.Length >= 1)
				{
					Players players11 = 检查玩家(账号排行11);
					if (players11 != null)
					{
						int num13 = players11.得到包裹空位位置();
						if (num13 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players11.UserName + "]赢得今日世界BOSS之战第11-20名");
							players11.增加物品带属性(BOSS1120名奖励物品ID, num13, 1, 0, 0, 0, 0, 0, 0);
							players11.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players11.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行12.Length >= 1)
				{
					Players players12 = 检查玩家(账号排行12);
					if (players12 != null)
					{
						int num14 = players12.得到包裹空位位置();
						if (num14 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players12.UserName + "]赢得今日世界BOSS之战第11-20名");
							players12.增加物品带属性(BOSS1120名奖励物品ID, num14, 1, 0, 0, 0, 0, 0, 0);
							players12.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players12.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行13.Length >= 1)
				{
					Players players13 = 检查玩家(账号排行13);
					if (players13 != null)
					{
						int num15 = players13.得到包裹空位位置();
						if (num15 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players13.UserName + "]赢得今日世界BOSS之战第11-20名");
							players13.增加物品带属性(BOSS1120名奖励物品ID, num15, 1, 0, 0, 0, 0, 0, 0);
							players13.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players13.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行14.Length >= 1)
				{
					Players players14 = 检查玩家(账号排行14);
					if (players14 != null)
					{
						int num16 = players14.得到包裹空位位置();
						if (num16 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players14.UserName + "]赢得今日世界BOSS之战第11-20名");
							players14.增加物品带属性(BOSS1120名奖励物品ID, num16, 1, 0, 0, 0, 0, 0, 0);
							players14.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players14.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行15.Length >= 1)
				{
					Players players15 = 检查玩家(账号排行15);
					if (players15 != null)
					{
						int num17 = players15.得到包裹空位位置();
						if (num17 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players15.UserName + "]赢得今日世界BOSS之战第11-20名");
							players15.增加物品带属性(BOSS1120名奖励物品ID, num17, 1, 0, 0, 0, 0, 0, 0);
							players15.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players15.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行16.Length >= 1)
				{
					Players players16 = 检查玩家(账号排行16);
					if (players16 != null)
					{
						int num18 = players16.得到包裹空位位置();
						if (num18 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players16.UserName + "]赢得今日世界BOSS之战第11-20名");
							players16.增加物品带属性(BOSS1120名奖励物品ID, num18, 1, 0, 0, 0, 0, 0, 0);
							players16.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players16.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行17.Length >= 1)
				{
					Players players17 = 检查玩家(账号排行17);
					if (players17 != null)
					{
						int num19 = players17.得到包裹空位位置();
						if (num19 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players17.UserName + "]赢得今日世界BOSS之战第11-20名");
							players17.增加物品带属性(BOSS1120名奖励物品ID, num19, 1, 0, 0, 0, 0, 0, 0);
							players17.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players17.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行18.Length >= 1)
				{
					Players players18 = 检查玩家(账号排行18);
					if (players18 != null)
					{
						int num20 = players18.得到包裹空位位置();
						if (num20 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players18.UserName + "]赢得今日世界BOSS之战第11-20名");
							players18.增加物品带属性(BOSS1120名奖励物品ID, num20, 1, 0, 0, 0, 0, 0, 0);
							players18.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players18.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行19.Length >= 1)
				{
					Players players19 = 检查玩家(账号排行19);
					if (players19 != null)
					{
						int num21 = players19.得到包裹空位位置();
						if (num21 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players19.UserName + "]赢得今日世界BOSS之战第11-20名");
							players19.增加物品带属性(BOSS1120名奖励物品ID, num21, 1, 0, 0, 0, 0, 0, 0);
							players19.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players19.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
				if (账号排行20.Length >= 1)
				{
					Players players20 = 检查玩家(账号排行20);
					if (players20 != null)
					{
						int num22 = players20.得到包裹空位位置();
						if (num22 >= 0)
						{
							全局提示("BOSS", 10, "恭喜玩家[" + players20.UserName + "]赢得今日世界BOSS之战第11-20名");
							players20.增加物品带属性(BOSS1120名奖励物品ID, num22, 1, 0, 0, 0, 0, 0, 0);
							players20.系统提示("获得奖励！", 10, "提示");
						}
						else
						{
							players20.系统提示("没有空位，本次没有获得奖励！", 10, "提示");
						}
					}
				}
			}
			catch (Exception)
			{
				Form1.WriteLine(1, "发奖励错误 ");
			}
		}

		private void 世界时间事件()
		{
			if (jlMsg == 1)
			{
				Form1.WriteLine(1, "世界时间事件()");
			}
			if (时间系统开关 != 0)
			{
				if (DateTime.Now.Hour == 0 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list = new List<Players>();
					foreach (Players value2 in allConnectedChars.Values)
					{
						list.Add(value2);
					}
					foreach (Players item in list)
					{
						item.服务器时间();
					}
				}
				if (DateTime.Now.Hour == 1 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list2 = new List<Players>();
					foreach (Players value3 in allConnectedChars.Values)
					{
						list2.Add(value3);
					}
					foreach (Players item2 in list2)
					{
						item2.服务器时间();
					}
				}
				if (DateTime.Now.Hour >= 2 && DateTime.Now.Hour <= 4 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list3 = new List<Players>();
					foreach (Players value4 in allConnectedChars.Values)
					{
						list3.Add(value4);
					}
					foreach (Players item3 in list3)
					{
						item3.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 5 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list4 = new List<Players>();
					foreach (Players value5 in allConnectedChars.Values)
					{
						list4.Add(value5);
					}
					foreach (Players item4 in list4)
					{
						item4.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 6 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list5 = new List<Players>();
					foreach (Players value6 in allConnectedChars.Values)
					{
						list5.Add(value6);
					}
					foreach (Players item5 in list5)
					{
						item5.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 7 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list6 = new List<Players>();
					foreach (Players value7 in allConnectedChars.Values)
					{
						list6.Add(value7);
					}
					foreach (Players item6 in list6)
					{
						item6.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 8 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list7 = new List<Players>();
					foreach (Players value8 in allConnectedChars.Values)
					{
						list7.Add(value8);
					}
					foreach (Players item7 in list7)
					{
						item7.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 9 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list8 = new List<Players>();
					foreach (Players value9 in allConnectedChars.Values)
					{
						list8.Add(value9);
					}
					foreach (Players item8 in list8)
					{
						item8.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 10 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list9 = new List<Players>();
					foreach (Players value10 in allConnectedChars.Values)
					{
						list9.Add(value10);
					}
					foreach (Players item9 in list9)
					{
						item9.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 11 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list10 = new List<Players>();
					foreach (Players value11 in allConnectedChars.Values)
					{
						list10.Add(value11);
					}
					foreach (Players item10 in list10)
					{
						item10.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 12 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list11 = new List<Players>();
					foreach (Players value12 in allConnectedChars.Values)
					{
						list11.Add(value12);
					}
					foreach (Players item11 in list11)
					{
						item11.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 13 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list12 = new List<Players>();
					foreach (Players value13 in allConnectedChars.Values)
					{
						list12.Add(value13);
					}
					foreach (Players item12 in list12)
					{
						item12.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 14 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list13 = new List<Players>();
					foreach (Players value14 in allConnectedChars.Values)
					{
						list13.Add(value14);
					}
					foreach (Players item13 in list13)
					{
						item13.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 15 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list14 = new List<Players>();
					foreach (Players value15 in allConnectedChars.Values)
					{
						list14.Add(value15);
					}
					foreach (Players item14 in list14)
					{
						item14.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 16 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list15 = new List<Players>();
					foreach (Players value16 in allConnectedChars.Values)
					{
						list15.Add(value16);
					}
					foreach (Players item15 in list15)
					{
						item15.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 17 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list16 = new List<Players>();
					foreach (Players value17 in allConnectedChars.Values)
					{
						list16.Add(value17);
					}
					foreach (Players item16 in list16)
					{
						item16.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 18 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list17 = new List<Players>();
					foreach (Players value18 in allConnectedChars.Values)
					{
						list17.Add(value18);
					}
					foreach (Players item17 in list17)
					{
						item17.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 19 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list18 = new List<Players>();
					foreach (Players value19 in allConnectedChars.Values)
					{
						list18.Add(value19);
					}
					foreach (Players item18 in list18)
					{
						item18.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 20 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list19 = new List<Players>();
					foreach (Players value20 in allConnectedChars.Values)
					{
						list19.Add(value20);
					}
					foreach (Players item19 in list19)
					{
						item19.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 21 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list20 = new List<Players>();
					foreach (Players value21 in allConnectedChars.Values)
					{
						list20.Add(value21);
					}
					foreach (Players item20 in list20)
					{
						item20.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 22 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list21 = new List<Players>();
					foreach (Players value22 in allConnectedChars.Values)
					{
						list21.Add(value22);
					}
					foreach (Players item21 in list21)
					{
						item21.服务器时间();
					}
				}
				else if (DateTime.Now.Hour == 23 && DateTime.Now.Second == 0 && DateTime.Now.Minute == 0)
				{
					List<Players> list22 = new List<Players>();
					foreach (Players value23 in allConnectedChars.Values)
					{
						list22.Add(value23);
					}
					foreach (Players item22 in list22)
					{
						item22.服务器时间();
					}
				}
			}
			核查掉线秒++;
			if (核查掉线秒 >= 2)
			{
				核查掉线秒 = 0;
			}
			if ((int)DateTime.Now.Subtract(离线挂机时间间隔).TotalMilliseconds >= 1500)
			{
				foreach (Players value24 in allConnectedChars.Values)
				{
					if (value24.离线挂机打怪模式 == 1)
					{
						value24.自动打怪();
					}
				}
				离线挂机时间间隔 = DateTime.Now;
			}
			世界时间 = DateTime.Now.Hour * 3600 + DateTime.Now.Minute * 60 + DateTime.Now.Second;
			if (是否开启BOSS挑战 == 1)
			{
				if (DateTime.Now.Minute == 0 && DateTime.Now.Second == 0)
				{
					if (DateTime.Now.Hour == 0)
					{
						BOSS地图.更新BOSS次数();
					}
					BOSS地图.chaeckBossInfo(DateTime.Now.Hour);
				}
				else if (DateTime.Now.Minute == 10 && DateTime.Now.Second == 0)
				{
					BOSS地图.resetBossInfo();
				}
			}
			if (BOOS总开关 == 1 && DateTime.Now.Hour == BOSS开启小时 && DateTime.Now.Minute == BOSS开启分钟 && (DateTime.Now.Second == BOSS开启秒 || DateTime.Now.Second == 势力战开启秒 + 1 || DateTime.Now.Second == 势力战开启秒 + 2))
			{
				BOSS倒计时秒 = 120;
				全局提示("BOSS", 10, "[120秒后]" + BOSS开启公告);
				Form1.WriteLine(2, "世界BOSS线程开启");
			}
			if (BOSS倒计时秒 >= 1)
			{
				BOSS倒计时秒--;
				if (BOSS倒计时秒 == 110 || BOSS倒计时秒 == 90 || BOSS倒计时秒 == 60 || BOSS倒计时秒 == 30 || BOSS倒计时秒 == 2)
				{
					全局提示("BOSS", 10, "[" + BOSS倒计时秒.ToString() + "秒后]" + BOSS开启公告);
				}
				if (BOSS倒计时秒 <= 2)
				{
					foreach (Players value25 in allConnectedChars.Values)
					{
						value25.累计伤害 = 0;
						Form1.WriteLine(2, "世界BOSS伤害归零");
					}
					conn.发送("全服公告|6|BOSS|今日BOSS伤害数据清零");
					DataTable dBToDataTable = DBA.GetDBToDataTable(string.Format("update TBL_人物数据 set FLD_BOSS伤害 = 0 ", "1"));
					BOSS进程秒 = 4;
					BOSS倒计时秒 = 0;
					AddNpc一次(BOSSPID, BOSS坐标X, BOSS坐标Y, BOSS的地图, 是否true: true, BOSS血, BOSS攻击, BOSS防御);
					全局提示("BOSS", 10, BOSS开启公告);
				}
			}
			if (BOSS进程秒 > 1)
			{
				BOSS进程秒++;
				if (BOSS存活秒 - BOSS进程秒 <= 1)
				{
					Form1.WriteLine(2, "世界BOSS线程结束");
					发奖励();
					全局提示("BOSS", 10, BOSS结束公告);
					全局提示("BOSS", 10, BOSS结束公告);
					全局提示("BOSS", 10, BOSS结束公告);
					BOSS进程秒 = 0;
					foreach (Players value26 in allConnectedChars.Values)
					{
						value26.保存人物数据存储过程();
					}
					Form1.WriteLine(2, "世界BOSS线程存档人物数据");
				}
			}
			for (int i = 0; i < 1000; i++)
			{
				if (掉线修复组队秒[i] >= 1)
				{
					掉线修复组队秒[i]--;
					if (掉线修复组队秒[i] <= 0)
					{
						掉线修复组队秒[i] = 0;
						掉线修复组队ID[i] = 0;
						掉线修复组队名字[i] = "";
					}
				}
			}
			if (世界时间事件累计秒 < 1)
			{
				世界时间事件累计秒++;
				int num = 0;
				for (int j = 0; j < 掉线修复组队名字.Length; j++)
				{
					num++;
					Console.WriteLine(掉线修复组队名字[j]);
					掉线修复组队名字[j] = "";
					掉线修复组队秒[j] = 0;
					掉线修复组队ID[j] = 0;
				}
				byte[] value = Guid.NewGuid().ToByteArray();
				int seed = BitConverter.ToInt32(value, 0);
				Random random = new Random(seed);
			}
			string s = DateTime.Now.ToString("dd");
			int num2 = int.Parse(s);
			if (num2 == 自动解封日期1 && 自动解封是否开启1 == 1 && DateTime.Now.Hour == 自动解封时1 && DateTime.Now.Minute == 自动解封分1 && DateTime.Now.Second == 0)
			{
				Config.IniWriteValue("GameServer", "人物最高等级", 自动解封等级1);
				Config.IniWriteValue("GameServer", "封印等级", 自动解封等级1);
				SetConfig();
				conn.发送("更新服务器配置|" + 服务器ID.ToString() + "|" + 最大在线.ToString());
				发送公告("系统已自动解封[" + 封印等级.ToString() + "]级，系统再次进行封印等为[" + 自动解封等级1 + "]级");
			}
			if (num2 == 自动解封日期2 && 自动解封是否开启2 == 1 && DateTime.Now.Hour == 自动解封时2 && DateTime.Now.Minute == 自动解封分2 && DateTime.Now.Second == 0)
			{
				Config.IniWriteValue("GameServer", "人物最高等级", 自动解封等级2);
				Config.IniWriteValue("GameServer", "封印等级", 自动解封等级2);
				SetConfig();
				conn.发送("更新服务器配置|" + 服务器ID.ToString() + "|" + 最大在线.ToString());
				发送公告("系统已自动解封[" + 封印等级.ToString() + "]级，系统再次进行封印等为[" + 自动解封等级2 + "]级");
			}
			if (num2 == 自动解封日期3 && 自动解封是否开启3 == 1 && DateTime.Now.Hour == 自动解封时3 && DateTime.Now.Minute == 自动解封分3 && DateTime.Now.Second == 0)
			{
				Config.IniWriteValue("GameServer", "人物最高等级", 自动解封等级3);
				Config.IniWriteValue("GameServer", "封印等级", 自动解封等级3);
				SetConfig();
				conn.发送("更新服务器配置|" + 服务器ID.ToString() + "|" + 最大在线.ToString());
				发送公告("系统已自动解封[" + 封印等级.ToString() + "]级，系统再次进行封印等为[" + 自动解封等级3 + "]级");
			}
			if (num2 == 自动解封日期4 && 自动解封是否开启4 == 1 && DateTime.Now.Hour == 自动解封时4 && DateTime.Now.Minute == 自动解封分4 && DateTime.Now.Second == 0)
			{
				Config.IniWriteValue("GameServer", "人物最高等级", 自动解封等级4);
				Config.IniWriteValue("GameServer", "封印等级", 自动解封等级4);
				SetConfig();
				conn.发送("更新服务器配置|" + 服务器ID.ToString() + "|" + 最大在线.ToString());
				发送公告("系统已自动解封[" + 封印等级.ToString() + "]级，系统再次进行封印等为[" + 自动解封等级4 + "]级");
			}
			if (科举是否开启 == 1 && DateTime.Now.Hour == 科举开启时 && DateTime.Now.Minute == 科举开启分 && DateTime.Now.Second == 科举开启秒 && 科举 == null)
			{
				科举 = new 科举系统();
				Form1.WriteLine(3, "科举开始");
			}
			if (彩票是否开启 == 1 && DateTime.Now.Hour == 彩票开启小时 && DateTime.Now.Minute == 彩票开启分 && DateTime.Now.Second == 彩票开启秒)
			{
				Random random2 = new Random(GetRandomSeed());
				new Random(GetRandomSeed());
				int num3 = random2.Next(1, 99);
				int num4 = random2.Next(1, 99);
				int num5 = random2.Next(1, 99);
				string msg = string.Format(彩票开奖内容, num3, num4, num5);
				发送公告(msg);
				if (购买彩票下注类型 == 0)
				{
					foreach (Players value27 in allConnectedChars.Values)
					{
						if (long.Parse(value27.彩票数据[0]) != 0)
						{
							for (int k = 1; k < value27.彩票数据.Length; k++)
							{
								if (int.Parse(value27.彩票数据[k]) == num3 || int.Parse(value27.彩票数据[k]) == num4 || int.Parse(value27.彩票数据[k]) == num5)
								{
									Players players = value27;
									players.彩票数++;
								}
							}
							if (value27.彩票数 == 3)
							{
								value27.百宝阁检察元宝数据(int.Parse(value27.彩票数据[0]) * 彩票全中倍数, 1);
								value27.系统提示("恭喜你三个号码全中,获得" + (long.Parse(value27.彩票数据[0]) * 彩票全中倍数).ToString() + "元宝数", 3, "开奖啦");
								value27.彩票数 = 0;
								for (int l = 0; l < value27.彩票数据.Length; l++)
								{
									value27.彩票数据[l] = "0";
								}
								value27.保存元宝数据();
								value27.保存人物的数据();
							}
							else if (value27.彩票数 == 2)
							{
								value27.百宝阁检察元宝数据(int.Parse(value27.彩票数据[0]) * 彩票中两个倍数, 1);
								value27.系统提示("恭喜你二个号码全中,获得" + (long.Parse(value27.彩票数据[0]) * 彩票中两个倍数).ToString() + "元宝数", 3, "开奖啦");
								value27.彩票数 = 0;
								for (int m = 0; m < value27.彩票数据.Length; m++)
								{
									value27.彩票数据[m] = "0";
								}
								value27.保存元宝数据();
								value27.保存人物的数据();
							}
							else if (int.Parse(value27.彩票数据[3]) == num5)
							{
								value27.百宝阁检察元宝数据(int.Parse(value27.彩票数据[0]) * 彩票中特别倍数, 1);
								value27.系统提示("恭喜你中特等奖号码,获得" + (long.Parse(value27.彩票数据[0]) * 彩票中特别倍数).ToString() + "元宝数", 3, "开奖啦");
								value27.彩票数 = 0;
								for (int n = 0; n < value27.彩票数据.Length; n++)
								{
									value27.彩票数据[n] = "0";
								}
								value27.保存元宝数据();
								value27.保存人物的数据();
							}
							else if (value27.彩票数 == 1)
							{
								value27.百宝阁检察元宝数据(int.Parse(value27.彩票数据[0]) * 彩票中一个倍数, 1);
								value27.系统提示("恭喜你一个号码全中,获得" + (long.Parse(value27.彩票数据[0]) * 彩票中一个倍数).ToString() + "元宝数", 3, "开奖啦");
								value27.彩票数 = 0;
								for (int num6 = 0; num6 < value27.彩票数据.Length; num6++)
								{
									value27.彩票数据[num6] = "0";
								}
								value27.保存元宝数据();
								value27.保存人物的数据();
							}
							else
							{
								value27.系统提示("抱歉你本期没有中奖，不要灰心大奖会属于你的！", 3, "开奖信息");
								for (int num7 = 0; num7 < value27.彩票数据.Length; num7++)
								{
									value27.彩票数据[num7] = "0";
								}
								value27.保存元宝数据();
								value27.保存人物的数据();
							}
						}
					}
				}
				if (购买彩票下注类型 == 1)
				{
					foreach (Players value28 in allConnectedChars.Values)
					{
						if (long.Parse(value28.彩票数据[0]) != 0)
						{
							for (int num8 = 1; num8 < value28.彩票数据.Length; num8++)
							{
								if (int.Parse(value28.彩票数据[num8]) == num3 || int.Parse(value28.彩票数据[num8]) == num4 || int.Parse(value28.彩票数据[num8]) == num5)
								{
									Players players = value28;
									players.彩票数++;
								}
							}
							if (value28.彩票数 == 3)
							{
								value28.百宝阁检察积分数据(int.Parse(value28.彩票数据[0]) * 彩票全中倍数, 1);
								value28.系统提示("恭喜你三个号码全中,获得" + (long.Parse(value28.彩票数据[0]) * 彩票全中倍数).ToString() + "积分数", 3, "开奖啦");
								value28.彩票数 = 0;
								for (int num9 = 0; num9 < value28.彩票数据.Length; num9++)
								{
									value28.彩票数据[num9] = "0";
								}
								value28.保存积分数据();
								value28.保存人物的数据();
							}
							else if (value28.彩票数 == 2)
							{
								value28.百宝阁检察积分数据(int.Parse(value28.彩票数据[0]) * 彩票中两个倍数, 1);
								value28.系统提示("恭喜你二个号码全中,获得" + (long.Parse(value28.彩票数据[0]) * 彩票中两个倍数).ToString() + "积分数", 3, "开奖啦");
								value28.彩票数 = 0;
								for (int num10 = 0; num10 < value28.彩票数据.Length; num10++)
								{
									value28.彩票数据[num10] = "0";
								}
								value28.保存积分数据();
								value28.保存人物的数据();
							}
							else if (int.Parse(value28.彩票数据[3]) == num5)
							{
								value28.百宝阁检察积分数据(int.Parse(value28.彩票数据[0]) * 彩票中特别倍数, 1);
								value28.系统提示("恭喜你中特等奖号码,获得" + (long.Parse(value28.彩票数据[0]) * 彩票中特别倍数).ToString() + "积分数", 3, "开奖啦");
								value28.彩票数 = 0;
								for (int num11 = 0; num11 < value28.彩票数据.Length; num11++)
								{
									value28.彩票数据[num11] = "0";
								}
								value28.保存积分数据();
								value28.保存人物的数据();
							}
							else if (value28.彩票数 == 1)
							{
								value28.百宝阁检察积分数据(int.Parse(value28.彩票数据[0]) * 彩票中一个倍数, 1);
								value28.系统提示("恭喜你一个号码全中,获得" + (long.Parse(value28.彩票数据[0]) * 彩票中一个倍数).ToString() + "积分数", 3, "开奖啦");
								value28.彩票数 = 0;
								for (int num12 = 0; num12 < value28.彩票数据.Length; num12++)
								{
									value28.彩票数据[num12] = "0";
								}
								value28.保存积分数据();
								value28.保存人物的数据();
							}
							else
							{
								value28.系统提示("抱歉你本期没有中奖，不要灰心大奖会属于你的！", 3, "开奖信息");
								for (int num13 = 0; num13 < value28.彩票数据.Length; num13++)
								{
									value28.彩票数据[num13] = "0";
								}
								value28.保存积分数据();
								value28.保存人物的数据();
							}
						}
					}
				}
				if (购买彩票下注类型 == 2)
				{
					foreach (Players value29 in allConnectedChars.Values)
					{
						if (long.Parse(value29.彩票数据[0]) != 0)
						{
							for (int num14 = 1; num14 < value29.彩票数据.Length; num14++)
							{
								if (int.Parse(value29.彩票数据[num14]) == num3 || int.Parse(value29.彩票数据[num14]) == num4 || int.Parse(value29.彩票数据[num14]) == num5)
								{
									Players players = value29;
									players.彩票数++;
								}
							}
							if (value29.彩票数 == 3)
							{
								value29.Player_WuXun += int.Parse(value29.彩票数据[0]) * 彩票全中倍数;
								value29.系统提示("恭喜你三个号码全中,获得" + (long.Parse(value29.彩票数据[0]) * 彩票全中倍数).ToString() + "武勋数", 3, "开奖啦");
								value29.彩票数 = 0;
								for (int num15 = 0; num15 < value29.彩票数据.Length; num15++)
								{
									value29.彩票数据[num15] = "0";
								}
								value29.更新武勋效果();
								value29.保存人物的数据();
							}
							else if (value29.彩票数 == 2)
							{
								value29.Player_WuXun += int.Parse(value29.彩票数据[0]) * 彩票中两个倍数;
								value29.系统提示("恭喜你二个号码全中,获得" + (long.Parse(value29.彩票数据[0]) * 彩票中两个倍数).ToString() + "武勋数", 3, "开奖啦");
								value29.彩票数 = 0;
								for (int num16 = 0; num16 < value29.彩票数据.Length; num16++)
								{
									value29.彩票数据[num16] = "0";
								}
								value29.更新武勋效果();
								value29.保存人物的数据();
							}
							else if (int.Parse(value29.彩票数据[3]) == num5)
							{
								value29.Player_WuXun += int.Parse(value29.彩票数据[0]) * 彩票中特别倍数;
								value29.系统提示("恭喜你中特等奖号码,获得" + (long.Parse(value29.彩票数据[0]) * 彩票中特别倍数).ToString() + "武勋数", 3, "开奖啦");
								value29.彩票数 = 0;
								for (int num17 = 0; num17 < value29.彩票数据.Length; num17++)
								{
									value29.彩票数据[num17] = "0";
								}
								value29.更新武勋效果();
								value29.保存人物的数据();
							}
							else if (value29.彩票数 == 1)
							{
								value29.Player_WuXun += int.Parse(value29.彩票数据[0]) * 彩票中一个倍数;
								value29.系统提示("恭喜你一个号码全中,获得" + (long.Parse(value29.彩票数据[0]) * 彩票中一个倍数).ToString() + "武勋数", 3, "开奖啦");
								value29.彩票数 = 0;
								for (int num18 = 0; num18 < value29.彩票数据.Length; num18++)
								{
									value29.彩票数据[num18] = "0";
								}
								value29.更新武勋效果();
								value29.保存人物的数据();
							}
							else
							{
								value29.系统提示("抱歉你本期没有中奖，不要灰心大奖会属于你的！", 3, "开奖信息");
								for (int num19 = 0; num19 < value29.彩票数据.Length; num19++)
								{
									value29.彩票数据[num19] = "0";
								}
								value29.更新武勋效果();
								value29.保存人物的数据();
							}
						}
					}
				}
			}
			if (异口同声是否开启 == 1 && DateTime.Now.Hour == 异口同声开启小时 && DateTime.Now.Minute == 异口同声开启分 && DateTime.Now.Second >= 异口同声开启秒 && ykts == null)
			{
				ykts = new 异口同声();
			}
			if (幸运奖是否开启 == 1 && DateTime.Now.Hour == 幸运奖开启小时 && DateTime.Now.Minute == 幸运奖开启分 && DateTime.Now.Second >= 幸运奖开启秒 && 幸运奖 == null)
			{
				幸运奖 = new StarClass();
			}
			if (皇号福利开关 == 1 && DateTime.Now.Hour == 皇号福利重置时间 && DateTime.Now.Minute == 0 && DateTime.Now.Second == 0)
			{
				DBA.ExeSqlCommand(string.Format("UPDATE TBL_人物数据 SET 大小次数=" + 0.ToString()), "GameServer");
				foreach (Players value30 in allConnectedChars.Values)
				{
					value30.大小次数 = 0;
					value30.保存人物的数据();
				}
				发送游戏特殊公告("皇号福利次数重置,每天【" + 皇号福利重置时间.ToString() + "点】准时自动重置,大家可以再次领取了", 10, "全服通知");
			}
			if (秘境开关 == 1 && DateTime.Now.Hour == 秘境重置时间 && DateTime.Now.Minute == 秘境重置时分 && DateTime.Now.Second == 0)
			{
				DBA.ExeSqlCommand(string.Format("UPDATE TBL_人物数据 SET 秘境次数=" + 0.ToString()), "GameServer");
				foreach (Players value31 in allConnectedChars.Values)
				{
					value31.秘境次数 = 0;
					value31.保存人物的数据();
				}
				发送游戏特殊公告("秘境挑战已重置,每天【" + 秘境重置时间.ToString() + "点" + 秘境重置时分.ToString() + "分】准时自动重置,大家可以再次挑战了", 10, "全服通知");
			}
			if (活动副本是否开启 == 1 && DateTime.Now.Hour == 活动副本开启小时 && DateTime.Now.Minute == 活动副本开启分 && DateTime.Now.Second == 0)
			{
				活动副本状态 = 1;
				发送游戏特殊公告(活动副本开启公告内容, 10, "系统提示");
			}
			if (活动副本状态 == 1 && DateTime.Now.Hour == 活动副本结束小时 && DateTime.Now.Minute == 活动副本结束分 && DateTime.Now.Second == 0)
			{
				活动副本状态 = 0;
				发送公告(活动副本结束公告内容);
				foreach (Players value32 in allConnectedChars.Values)
				{
					if (value32.人物坐标_地图 == 活动副本地图ID)
					{
						value32.移动(500f, 2200f, 15f, 101);
					}
				}
			}
			int num20 = Convert.ToInt32(DateTime.Today.DayOfWeek);
			if (num20 == 攻城战星期几开 && 攻城战是否开启 == 1 && DateTime.Now.Hour == 攻城战开启小时 && DateTime.Now.Minute == 攻城战开启分 && DateTime.Now.Second >= 攻城战开启秒 && 攻城 == null)
			{
				DBA.ExeSqlCommand(string.Format("UPDATE TBL_人物数据 SET 攻城BUFF=" + 0.ToString()), "GameServer");
				foreach (Players value33 in allConnectedChars.Values)
				{
					value33.攻城BUFF = 0;
					value33.保存人物的数据();
					if (value33.追加状态列表.ContainsKey(1008000212))
					{
						追加状态类 追加状态类 = value33.追加状态列表[1008000212];
						追加状态类.时间结束事件();
					}
				}
				Form1.WriteLine(3, "自动攻城战开启成功");
				攻城 = new 攻城Class();
			}
			if (DateTime.Now.Hour == 被杀武勋清零时 && DateTime.Now.Minute == 被杀武勋清零分 && DateTime.Now.Second == 0)
			{
				DBA.ExeSqlCommand(string.Format("UPDATE TBL_人物数据 SET 被杀武勋=" + 0.ToString()), "GameServer");
				foreach (Players value34 in allConnectedChars.Values)
				{
					value34.被杀武勋 = 0;
					value34.保存人物的数据();
				}
			}
			if (是否开启世界随机BOSS一 == 1 && DateTime.Now.Hour == 刷新BOSS时间一 && DateTime.Now.Minute == 刷新BOSS时分一 && DateTime.Now.Second == 刷新BOSS时秒一)
			{
				Random random3 = new Random();
				int num21 = random3.Next(0, 2000);
				int num22 = random3.Next(0, 2000);
				int num23 = random3.Next(0, 2000);
				int num24 = random3.Next(0, 2000);
				int num25 = random3.Next(0, 2000);
				int num26 = random3.Next(0, 2000);
				int num27 = random3.Next(0, 2000);
				int num28 = random3.Next(0, 2000);
				if (刷武勋BOSS开关 != 0)
				{
					AddNpc(刷新BOSS怪物ID一, num21, num22, 刷新BOSS所在地图ID一);
				}
				if (刷元宝BOSS开关 != 0)
				{
					AddNpc(刷新BOSS怪物ID二, num23, num24, 刷新BOSS所在地图ID一);
				}
				if (刷积分BOSS开关 != 0)
				{
					AddNpc(刷新BOSS怪物ID三, num25, num26, 刷新BOSS所在地图ID一);
				}
				if (刷金币BOSS开关 != 0)
				{
					AddNpc(刷新BOSS怪物ID四, num27, num28, 刷新BOSS所在地图ID一);
				}
				if (是否开启提示刷新BOSS坐标 == 1)
				{
					if (刷武勋BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容一 + "→坐标X:" + num21.ToString() + " 坐标Y:" + num22.ToString(), 10, "系统提示");
					}
					if (刷元宝BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容二 + "→坐标X:" + num23.ToString() + " 坐标Y:" + num24.ToString(), 10, "系统提示");
					}
					if (刷积分BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容三 + "→坐标X:" + num25.ToString() + " 坐标Y:" + num26.ToString(), 10, "系统提示");
					}
					if (刷金币BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容四 + "→坐标X:" + num27.ToString() + " 坐标Y:" + num28.ToString(), 10, "系统提示");
					}
				}
				if (是否开启提示刷新BOSS坐标 == 0)
				{
					if (刷武勋BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容一, 10, "系统提示");
					}
					if (刷元宝BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容二, 10, "系统提示");
					}
					if (刷积分BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容三, 10, "系统提示");
					}
					if (刷金币BOSS开关 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容四, 10, "系统提示");
					}
				}
			}
			if (是否开启世界随机BOSS一 == 1 && DateTime.Now.Hour == 删除BOSS时间一 && DateTime.Now.Minute == 删除BOSS时分一 && DateTime.Now.Second == 删除BOSS时秒一)
			{
				delNpc(刷新BOSS所在地图ID一, 刷新BOSS怪物ID一);
				delNpc(刷新BOSS所在地图ID一, 刷新BOSS怪物ID二);
				delNpc(刷新BOSS所在地图ID一, 刷新BOSS怪物ID三);
				delNpc(刷新BOSS所在地图ID一, 刷新BOSS怪物ID四);
			}
			if (是否开启世界随机BOSS二 == 1 && DateTime.Now.Hour == 刷新BOSS时间二 && DateTime.Now.Minute == 刷新BOSS时分二 && DateTime.Now.Second == 刷新BOSS时秒二)
			{
				Random random4 = new Random();
				int num29 = random4.Next(0, 2000);
				int num30 = random4.Next(0, 2000);
				int num31 = random4.Next(0, 2000);
				int num32 = random4.Next(0, 2000);
				int num33 = random4.Next(0, 2000);
				int num34 = random4.Next(0, 2000);
				int num35 = random4.Next(0, 2000);
				int num36 = random4.Next(0, 2000);
				if (刷武勋BOSS开关1 != 0)
				{
					AddBossEveNpc(刷新BOSS怪物ID一二, num29, num30, 刷新BOSS所在地图ID二);
				}
				if (刷元宝BOSS开关1 != 0)
				{
					AddBossEveNpc(刷新BOSS怪物ID二二, num31, num32, 刷新BOSS所在地图ID二);
				}
				if (刷积分BOSS开关1 != 0)
				{
					AddBossEveNpc(刷新BOSS怪物ID三二, num33, num34, 刷新BOSS所在地图ID二);
				}
				if (刷金币BOSS开关1 != 0)
				{
					AddBossEveNpc(刷新BOSS怪物ID四二, num35, num36, 刷新BOSS所在地图ID二);
				}
				if (是否开启提示刷新BOSS坐标 == 1)
				{
					if (刷武勋BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容一二 + "→坐标X:" + num29.ToString() + " 坐标Y:" + num30.ToString(), 10, "系统提示");
					}
					if (刷元宝BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容二二 + "→坐标X:" + num31.ToString() + " 坐标Y:" + num32.ToString(), 10, "系统提示");
					}
					if (刷积分BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容三二 + "→坐标X:" + num33.ToString() + " 坐标Y:" + num34.ToString(), 10, "系统提示");
					}
					if (刷金币BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容四二 + "→坐标X:" + num35.ToString() + " 坐标Y:" + num36.ToString(), 10, "系统提示");
					}
				}
				if (是否开启提示刷新BOSS坐标 == 0)
				{
					if (刷武勋BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容一二, 10, "系统提示");
					}
					if (刷元宝BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容二二, 10, "系统提示");
					}
					if (刷积分BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容三二, 10, "系统提示");
					}
					if (刷金币BOSS开关1 != 0)
					{
						发送游戏特殊公告(刷新BOSS提示内容四二, 10, "系统提示");
					}
				}
			}
			if (是否开启世界随机BOSS二 == 1 && DateTime.Now.Hour == 删除BOSS时间二 && DateTime.Now.Minute == 删除BOSS时分二 && DateTime.Now.Second == 删除BOSS时秒二)
			{
				delNpcq(刷新BOSS所在地图ID二, 刷新BOSS怪物ID一二);
				delNpcq(刷新BOSS所在地图ID二, 刷新BOSS怪物ID二二);
				delNpcq(刷新BOSS所在地图ID二, 刷新BOSS怪物ID三二);
				delNpcq(刷新BOSS所在地图ID二, 刷新BOSS怪物ID四二);
			}
			if (当前线路类型 == 0)
			{
				if (副本开始时间 != 副本结束时间)
				{
					if (DateTime.Now.Hour == 副本开始时间 && DateTime.Now.Minute == 0 && DateTime.Now.Second >= 0 && 副本开启状态 == 0)
					{
						副本开启状态 = 1;
						更新副本次数();
						发送公告("4转伏魔洞副本开启,勇士们战斗吧！可获得大量经验和物品");
					}
					else if (DateTime.Now.Hour == 副本结束时间 && DateTime.Now.Minute == 0 && DateTime.Now.Second >= 0 && 副本开启状态 == 1)
					{
						副本开启状态 = 0;
						发送公告("伏魔洞副本结束！");
					}
				}
				if (DateTime.Now.Hour == 限时地图开PK时间)
				{
					if (限时地图是否开启 == 0)
					{
						限时地图是否开启 = 1;
						发送地图PK公告(1);
					}
				}
				else if (DateTime.Now.Hour == 限时地图关PK时间 && 限时地图是否开启 == 1)
				{
					限时地图是否开启 = 0;
					发送地图PK公告(0);
				}
				int num37 = Convert.ToInt32(DateTime.Today.DayOfWeek);
				if (num37 < 5 && 周末全天PK是否开启 == 1)
				{
					if (DateTime.Now.Hour == 工作日限时地图开PK时间)
					{
						if (工作日限时地图是否开启 == 0)
						{
							工作日限时地图是否开启 = 1;
							发送地图PK公告2(1);
						}
					}
					else if (DateTime.Now.Hour == 工作日限时地图关PK时间 && 工作日限时地图是否开启 == 1)
					{
						工作日限时地图是否开启 = 0;
						发送地图PK公告2(0);
					}
				}
				if (势力战是否开启 == 1)
				{
					int weekName = GetWeekName();
					if (DateTime.Now.Hour == 三转势力战开启小时 && DateTime.Now.Minute == 势力战开启分 && DateTime.Now.Second == 势力战开启秒)
					{
						if (eve == null)
						{
							势力战进程 = 0;
							势力战时间 = 0;
							势力战正分数 = 0;
							势力战邪分数 = 0;
							eve = new EventClass(3);
							Form1.WriteLine(3, "势力开始");
						}
					}
					else if (DateTime.Now.Hour == 四转势力战开启小时 && DateTime.Now.Minute == 势力战开启分 && DateTime.Now.Second == 势力战开启秒 && eve == null)
					{
						势力战进程 = 0;
						势力战时间 = 0;
						势力战正分数 = 0;
						势力战邪分数 = 0;
						eve = new EventClass(4);
					}
				}
				if (门战是否开启 == 1 && DateTime.Now.Hour == 门战开启小时1 && DateTime.Now.Minute == 门战战开启分 && DateTime.Now.Second >= 门战战开启秒 && 门战 == null)
				{
					门战 = new 帮派战_门战();
					Form1.WriteLine(3, "门站开始");
				}
				if (乱斗系统是否开启 == 1 && DateTime.Now.Hour == 乱斗开启时 && DateTime.Now.Minute == 乱斗开启分 && DateTime.Now.Second >= 乱斗开启秒 && Luandou == null)
				{
					Luandou = new 无限乱斗();
					Form1.WriteLine(3, "排位赛开始");
				}
				if (!(高倍经验倍数 > 1.0))
				{
					return;
				}
				if (是否开启高倍经验开关 == 1 && DateTime.Now.Hour == 高倍经验开启时间 && DateTime.Now.Minute == 高倍经验开启分间 && DateTime.Now.Second == 高倍经验开启秒间)
				{
					if (是否开启高倍经验 == 0)
					{
						是否开启高倍经验 = 1;
						发送公告(高倍经验倍数.ToString() + "倍经验开启！");
					}
				}
				else if (是否开启高倍经验开关 == 1 && DateTime.Now.Hour == 高倍经验结束时间 && DateTime.Now.Minute == 高倍经验结束分间 && DateTime.Now.Second == 高倍经验结束秒间 && 是否开启高倍经验 == 1)
				{
					是否开启高倍经验 = 0;
					发送公告(高倍经验倍数.ToString() + "倍经验结束！");
				}
				return;
			}
			限时地图是否开启 = 1;
			工作日限时地图是否开启 = 1;
			if (势力战是否开启 == 1)
			{
				int weekName2 = GetWeekName();
				if (DateTime.Now.Hour == 三转势力战开启小时 && DateTime.Now.Minute == 势力战开启分 && DateTime.Now.Second == 势力战开启秒)
				{
					if (eve == null)
					{
						势力战进程 = 0;
						势力战时间 = 0;
						势力战正分数 = 0;
						势力战邪分数 = 0;
						eve = new EventClass(3);
						Form1.WriteLine(3, "势力开始");
					}
				}
				else if (DateTime.Now.Hour == 四转势力战开启小时 && DateTime.Now.Minute == 势力战开启分 && DateTime.Now.Second == 势力战开启秒 && eve == null)
				{
					势力战进程 = 0;
					势力战时间 = 0;
					势力战正分数 = 0;
					势力战邪分数 = 0;
					eve = new EventClass(4);
				}
			}
			if (门战是否开启 == 1 && DateTime.Now.Hour == 门战开启小时1 && DateTime.Now.Minute == 门战战开启分 && DateTime.Now.Second >= 门战战开启秒 && 门战 == null)
			{
				门战 = new 帮派战_门战();
				Form1.WriteLine(3, "门站开始");
			}
			if (乱斗系统是否开启 == 1 && DateTime.Now.Hour == 乱斗开启时 && DateTime.Now.Minute == 乱斗开启分 && DateTime.Now.Second >= 乱斗开启秒 && Luandou == null)
			{
				Luandou = new 无限乱斗();
				Form1.WriteLine(3, "排位赛开始");
			}
		}

		public static void 端口更换通知()
		{
			foreach (WGHandler client in WGServer.clients)
			{
				client.Sendd("更新服务器端口|" + 服务器ID.ToString() + "|" + 游戏服务器端口1.ToString());
			}
		}

		public static void 端口更换通知(string serverid)
		{
			foreach (WGHandler client in WGServer.clients)
			{
				if (client.ServerId == serverid)
				{
					client.Sendd("更新服务器端口|" + 游戏服务器端口1.ToString());
				}
			}
		}

		public World()
		{
			Timer.DelayCall(TimeSpan.FromMilliseconds(1000.0), TimeSpan.FromMilliseconds(1000.0), 世界时间事件);
		}

		public void SetScript()
		{
			脚本 = new ScriptClass();
		}

		public void SetConfig()
		{
			string text = "";
			try
			{
				text = "游戏相关配置.ini";
				Config.Path = Application.StartupPath + "\\游戏相关配置.ini";
				text = "死亡扣除武勋";
				死亡扣除武勋 = int.Parse(Config.IniReadValue("GameServer", "死亡扣除武勋").Trim());
				text = "杀人获得武勋";
				杀人获得武勋 = int.Parse(Config.IniReadValue("GameServer", "杀人获得武勋").Trim());
				text = "会员经验百分比";
				会员经验百分比 = double.Parse(Config.IniReadValue("GameServer", "会员经验百分比").Trim());
				text = "会员金钱百分比";
				会员金钱百分比 = double.Parse(Config.IniReadValue("GameServer", "会员金钱百分比").Trim());
				text = "会员历练百分比";
				会员历练百分比 = double.Parse(Config.IniReadValue("GameServer", "会员历练百分比").Trim());
				text = "会员爆率百分比";
				会员爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "会员爆率百分比").Trim());
				text = "时间系统开关";
				时间系统开关 = int.Parse(Config.IniReadValue("GameServer", "时间系统开关").Trim());
				text = "会员专用地图";
				会员专用地图 = int.Parse(Config.IniReadValue("GameServer", "会员专用地图").Trim());
				text = "自动解封是否开启1";
				自动解封是否开启1 = int.Parse(Config.IniReadValue("GameServer", "自动解封是否开启1").Trim());
				text = "自动解封日期1";
				自动解封日期1 = int.Parse(Config.IniReadValue("GameServer", "自动解封日期1").Trim());
				text = "自动解封时1";
				自动解封时1 = int.Parse(Config.IniReadValue("GameServer", "自动解封时1").Trim());
				text = "自动解封分1";
				自动解封分1 = int.Parse(Config.IniReadValue("GameServer", "自动解封分1").Trim());
				text = "自动解封等级1";
				自动解封等级1 = Config.IniReadValue("GameServer", "自动解封等级1").Trim();
				text = "自动解封判断1";
				自动解封判断1 = int.Parse(Config.IniReadValue("GameServer", "自动解封判断1").Trim());
				text = "自动封印天数1";
				自动封印天数1 = int.Parse(Config.IniReadValue("GameServer", "自动封印天数1").Trim());
				text = "自动解封是否开启2";
				自动解封是否开启2 = int.Parse(Config.IniReadValue("GameServer", "自动解封是否开启2").Trim());
				text = "自动解封日期2";
				自动解封日期2 = int.Parse(Config.IniReadValue("GameServer", "自动解封日期2").Trim());
				text = "自动解封时2";
				自动解封时2 = int.Parse(Config.IniReadValue("GameServer", "自动解封时2").Trim());
				text = "自动解封分2";
				自动解封分2 = int.Parse(Config.IniReadValue("GameServer", "自动解封分2").Trim());
				text = "自动解封等级2";
				自动解封等级2 = Config.IniReadValue("GameServer", "自动解封等级2").Trim();
				text = "自动解封判断2";
				自动解封判断2 = int.Parse(Config.IniReadValue("GameServer", "自动解封判断2").Trim());
				text = "自动封印天数2";
				自动封印天数2 = int.Parse(Config.IniReadValue("GameServer", "自动封印天数2").Trim());
				text = "自动解封是否开启3";
				自动解封是否开启3 = int.Parse(Config.IniReadValue("GameServer", "自动解封是否开启3").Trim());
				text = "自动解封日期3";
				自动解封日期3 = int.Parse(Config.IniReadValue("GameServer", "自动解封日期3").Trim());
				text = "自动解封时3";
				自动解封时3 = int.Parse(Config.IniReadValue("GameServer", "自动解封时3").Trim());
				text = "自动解封分3";
				自动解封分3 = int.Parse(Config.IniReadValue("GameServer", "自动解封分3").Trim());
				text = "自动解封等级3";
				自动解封等级3 = Config.IniReadValue("GameServer", "自动解封等级3").Trim();
				text = "自动解封判断3";
				自动解封判断3 = int.Parse(Config.IniReadValue("GameServer", "自动解封判断3").Trim());
				text = "自动封印天数3";
				自动封印天数3 = int.Parse(Config.IniReadValue("GameServer", "自动封印天数3").Trim());
				text = "自动解封是否开启4";
				自动解封是否开启4 = int.Parse(Config.IniReadValue("GameServer", "自动解封是否开启4").Trim());
				text = "自动解封日期4";
				自动解封日期4 = int.Parse(Config.IniReadValue("GameServer", "自动解封日期4").Trim());
				text = "自动解封时4";
				自动解封时4 = int.Parse(Config.IniReadValue("GameServer", "自动解封时4").Trim());
				text = "自动解封分4";
				自动解封分4 = int.Parse(Config.IniReadValue("GameServer", "自动解封分4").Trim());
				text = "自动解封等级4";
				自动解封等级4 = Config.IniReadValue("GameServer", "自动解封等级4").Trim();
				text = "自动解封判断4";
				自动解封判断4 = int.Parse(Config.IniReadValue("GameServer", "自动解封判断4").Trim());
				text = "自动封印天数4";
				自动封印天数4 = int.Parse(Config.IniReadValue("GameServer", "自动封印天数4").Trim());
				text = "是否开启物品回收";
				是否开启物品回收 = int.Parse(Config.IniReadValue("GameServer", "是否开启物品回收").Trim());
				text = "攻城战BUFF有效期";
				攻城战BUFF有效期 = int.Parse(Config.IniReadValue("GameServer", "攻城战BUFF有效期").Trim());
				text = "攻城战星期几开";
				攻城战星期几开 = int.Parse(Config.IniReadValue("GameServer", "攻城战星期几开").Trim());
				text = "被杀武勋清零时";
				被杀武勋清零时 = int.Parse(Config.IniReadValue("GameServer", "被杀武勋清零时").Trim());
				text = "被杀武勋限制";
				被杀武勋限制 = int.Parse(Config.IniReadValue("GameServer", "被杀武勋限制").Trim());
				text = "被杀武勋清零分";
				被杀武勋清零分 = int.Parse(Config.IniReadValue("GameServer", "被杀武勋清零分").Trim());
				text = "弓全队678";
				弓全队678 = int.Parse(Config.IniReadValue("GameServer", "弓全队678").Trim());
				text = "喊话等级限制";
				喊话等级限制 = int.Parse(Config.IniReadValue("GameServer", "喊话等级限制").Trim());
				text = "抓宠命令";
				抓宠命令 = Config.IniReadValue("GameServer", "抓宠命令").Trim();
				text = "定点命令";
				定点命令 = Config.IniReadValue("GameServer", "定点命令").Trim();
				text = "跟随命令";
				跟随命令 = Config.IniReadValue("GameServer", "跟随命令").Trim();
				text = "放生命令";
				放生命令 = Config.IniReadValue("GameServer", "放生命令").Trim();
				text = "召唤命令";
				召唤命令 = Config.IniReadValue("GameServer", "召唤命令").Trim();
				text = "召回命令";
				召回命令 = Config.IniReadValue("GameServer", "召回命令").Trim();
				text = "进阶命令";
				进阶命令 = Config.IniReadValue("GameServer", "进阶命令").Trim();
				text = "收宠所需ID";
				收宠所需ID = Config.IniReadValue("GameServer", "收宠所需ID").Trim();
				text = "收宠机率";
				收宠机率 = ((!(Config.IniReadValue("GameServer", "宠物收服概率").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "宠物收服概率").Trim()) : 0);
				text = "宠物进阶所需物品ID";
				宠物进阶所需物品ID = Config.IniReadValue("GameServer", "宠物进阶所需物品ID").Trim();
				text = "宠物进阶最阶段";
				宠物进阶高阶段 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶高阶段").Trim());
				text = "野宠进阶成功率";
				野宠进阶成功率 = Config.IniReadValue("GameServer", "野宠进阶成功率").Trim();
				text = "宠物加属性1";
				宠物加属性1 = Config.IniReadValue("GameServer", "宠物加属性1").Trim().Split(';');
				text = "宠物加属性2";
				宠物加属性2 = Config.IniReadValue("GameServer", "宠物加属性2").Trim().Split(';');
				text = "宠物加属性3";
				宠物加属性3 = Config.IniReadValue("GameServer", "宠物加属性3").Trim().Split(';');
				text = "宠物加属性4";
				宠物加属性4 = Config.IniReadValue("GameServer", "宠物加属性4").Trim().Split(';');
				text = "宠物加属性5";
				宠物加属性5 = Config.IniReadValue("GameServer", "宠物加属性5").Trim().Split(';');
				text = "宠物加属性6";
				宠物加属性6 = Config.IniReadValue("GameServer", "宠物加属性6").Trim().Split(';');
				text = "宠物加属性7";
				宠物加属性7 = Config.IniReadValue("GameServer", "宠物加属性7").Trim().Split(';');
				text = "宠物加属性8";
				宠物加属性8 = Config.IniReadValue("GameServer", "宠物加属性8").Trim().Split(';');
				text = "宠物加属性9";
				宠物加属性9 = Config.IniReadValue("GameServer", "宠物加属性9").Trim().Split(';');
				text = "宠物加属性10";
				宠物加属性10 = Config.IniReadValue("GameServer", "宠物加属性10").Trim().Split(';');
				text = "宠物进阶公告";
				宠物进阶公告 = Config.IniReadValue("GameServer", "宠物进阶公告").Trim();
				text = "宠物进阶保护";
				宠物进阶保护 = Config.IniReadValue("GameServer", "宠物进阶保护").Trim();
				text = "全服开箱掉落颜色提示";
				全服开箱掉落颜色提示 = int.Parse(Config.IniReadValue("GameServer", "全服开箱掉落颜色提示").Trim());
				text = "强化全线提示颜色";
				强化全线提示颜色 = int.Parse(Config.IniReadValue("GameServer", "强化全线提示颜色").Trim());
				text = "是否开启全服开箱提示";
				是否开启全服开箱提示 = int.Parse(Config.IniReadValue("GameServer", "是否开启全服开箱提示").Trim());
				text = "是否开启全服掉落提示";
				是否开启全服掉落提示 = int.Parse(Config.IniReadValue("GameServer", "是否开启全服掉落提示").Trim());
				text = "是否开启全服上线提示";
				是否开启全服上线提示 = int.Parse(Config.IniReadValue("GameServer", "是否开启全服上线提示").Trim());
				text = "是否开启摸金副本地图";
				是否开启摸金副本地图 = int.Parse(Config.IniReadValue("GameServer", "是否开启摸金副本地图").Trim());
				text = "摸金提示内容";
				摸金提示内容 = Config.IniReadValue("GameServer", "摸金提示内容").Trim();
				text = "刀客无爆率";
				刀客无爆率 = int.Parse(Config.IniReadValue("GameServer", "刀客无爆率").Trim());
				text = "剑客无爆率";
				剑客无爆率 = int.Parse(Config.IniReadValue("GameServer", "剑客无爆率").Trim());
				text = "枪客无爆率";
				枪客无爆率 = int.Parse(Config.IniReadValue("GameServer", "枪客无爆率").Trim());
				text = "弓箭手无爆率";
				弓箭手无爆率 = int.Parse(Config.IniReadValue("GameServer", "弓箭手无爆率").Trim());
				text = "医生无爆率";
				医生无爆率 = int.Parse(Config.IniReadValue("GameServer", "医生无爆率").Trim());
				text = "创建门派需要金钱";
				创建门派需要金钱 = ((Config.IniReadValue("GameServer", "创建门派需要金钱").Trim() == "") ? 创建门派需要金钱 : int.Parse(Config.IniReadValue("GameServer", "创建门派需要金钱").Trim()));
				text = "信任连接IP";
				信任连接IP = Config.IniReadValue("GameServer", "信任连接IP").Trim();
				text = "允许多开数量";
				允许多开数量 = ((Config.IniReadValue("GameServer", "允许多开数量").Trim() == "") ? 允许多开数量 : int.Parse(Config.IniReadValue("GameServer", "允许多开数量").Trim()));
				text = "土豪经验金币数";
				土豪经验金币数 = ((!(Config.IniReadValue("GameServer", "土豪经验金币数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "土豪经验金币数").Trim()) : 0);
				text = "土豪经验持续时间";
				土豪经验持续时间 = ((!(Config.IniReadValue("GameServer", "土豪经验持续时间").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "土豪经验持续时间").Trim()) : 0);
				text = "土豪经验百分比";
				土豪经验百分比 = double.Parse(Config.IniReadValue("GameServer", "土豪经验百分比").Trim());
				text = "土豪爆率百分比";
				土豪爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "土豪爆率百分比").Trim());
				text = "队伍经验持续时间";
				队伍经验持续时间 = ((!(Config.IniReadValue("GameServer", "队伍经验持续时间").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "队伍经验持续时间").Trim()) : 0);
				text = "队伍经验百分比";
				队伍经验百分比 = double.Parse(Config.IniReadValue("GameServer", "队伍经验百分比").Trim());
				text = "队伍爆率百分比";
				队伍爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "队伍爆率百分比").Trim());
				text = "门派经验金币数";
				门派经验金币数 = ((!(Config.IniReadValue("GameServer", "门派经验金币数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门派经验金币数").Trim()) : 0);
				text = "门派经验元宝数";
				门派经验元宝数 = ((!(Config.IniReadValue("GameServer", "门派经验元宝数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门派经验元宝数").Trim()) : 0);
				text = "门派经验积分数";
				门派经验积分数 = ((!(Config.IniReadValue("GameServer", "门派经验积分数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门派经验积分数").Trim()) : 0);
				text = "门派经验持续时间";
				门派经验持续时间 = ((!(Config.IniReadValue("GameServer", "门派经验持续时间").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门派经验持续时间").Trim()) : 0);
				text = "门派经验百分比";
				门派经验百分比 = double.Parse(Config.IniReadValue("GameServer", "门派经验百分比").Trim());
				text = "门派爆率百分比";
				门派爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "门派爆率百分比").Trim());
				text = "是否开启土豪系统";
				是否开启土豪系统 = ((Config.IniReadValue("GameServer", "是否开启土豪系统").Trim() == "") ? 是否开启土豪系统 : int.Parse(Config.IniReadValue("GameServer", "是否开启土豪系统").Trim()));
				text = "全服土豪需要积分";
				全服土豪需要积分 = ((Config.IniReadValue("GameServer", "全服土豪需要积分").Trim() == "") ? 全服土豪需要积分 : int.Parse(Config.IniReadValue("GameServer", "全服土豪需要积分").Trim()));
				text = "全服土豪需要元宝";
				全服土豪需要元宝 = ((Config.IniReadValue("GameServer", "全服土豪需要元宝").Trim() == "") ? 全服土豪需要元宝 : int.Parse(Config.IniReadValue("GameServer", "全服土豪需要元宝").Trim()));
				text = "队伍土豪需要元宝";
				队伍土豪需要元宝 = ((Config.IniReadValue("GameServer", "队伍土豪需要元宝").Trim() == "") ? 队伍土豪需要元宝 : int.Parse(Config.IniReadValue("GameServer", "队伍土豪需要元宝").Trim()));
				text = "队伍土豪需要金币";
				队伍土豪需要金币 = ((Config.IniReadValue("GameServer", "队伍土豪需要金币").Trim() == "") ? 队伍土豪需要金币 : int.Parse(Config.IniReadValue("GameServer", "队伍土豪需要金币").Trim()));
				text = "队伍土豪需要积分";
				队伍土豪需要积分 = ((Config.IniReadValue("GameServer", "队伍土豪需要积分").Trim() == "") ? 队伍土豪需要积分 : int.Parse(Config.IniReadValue("GameServer", "队伍土豪需要积分").Trim()));
				text = "坐牢系统是否开启";
				坐牢系统是否开启 = int.Parse(Config.IniReadValue("GameServer", "坐牢系统是否开启").Trim());
				text = "监狱地图";
				监狱地图 = Config.IniReadValue("GameServer", "监狱地图").Trim();
				text = "坐牢善恶";
				坐牢善恶 = int.Parse(Config.IniReadValue("GameServer", "坐牢善恶").Trim());
				text = "坐牢善恶恢复间隔";
				坐牢善恶恢复间隔 = int.Parse(Config.IniReadValue("GameServer", "坐牢善恶恢复间隔").Trim());
				text = "坐牢恢复善恶值";
				坐牢恢复善恶值 = int.Parse(Config.IniReadValue("GameServer", "坐牢恢复善恶值").Trim());
				text = "坐牢回城坐标";
				坐牢回城坐标 = Config.IniReadValue("GameServer", "坐牢回城坐标").Trim();
				text = "坐牢杀人公告";
				坐牢杀人公告 = ((Config.IniReadValue("GameServer", "坐牢杀人公告").Trim() == "") ? 坐牢杀人公告 : Config.IniReadValue("GameServer", "坐牢杀人公告").Trim());
				text = "刑满释放公告";
				刑满释放公告 = ((Config.IniReadValue("GameServer", "刑满释放公告").Trim() == "") ? 刑满释放公告 : Config.IniReadValue("GameServer", "刑满释放公告").Trim());
				text = "武功防模式";
				武功防模式 = ((Config.IniReadValue("GameServer", "武功防模式").Trim() == "") ? 武功防模式 : int.Parse(Config.IniReadValue("GameServer", "武功防模式").Trim()));
				text = "属性扩展是否开启";
				属性扩展是否开启 = int.Parse(Config.IniReadValue("GameServer", "属性扩展是否开启").Trim());
				text = "上线属性提示开关";
				上线属性提示开关 = int.Parse(Config.IniReadValue("GameServer", "上线属性提示开关").Trim());
				text = "个人状态0";
				个人状态0 = Config.IniReadValue("GameServer", "个人状态0").Trim();
				text = "个人状态1";
				个人状态1 = Config.IniReadValue("GameServer", "个人状态1").Trim();
				text = "个人状态2";
				个人状态2 = Config.IniReadValue("GameServer", "个人状态2").Trim();
				text = "个人状态3";
				个人状态3 = Config.IniReadValue("GameServer", "个人状态3").Trim();
				text = "个人状态4";
				个人状态4 = Config.IniReadValue("GameServer", "个人状态4").Trim();
				text = "个人状态5";
				个人状态5 = Config.IniReadValue("GameServer", "个人状态5").Trim();
				text = "个人状态6";
				个人状态6 = Config.IniReadValue("GameServer", "个人状态6").Trim();
				text = "个人状态7";
				个人状态7 = Config.IniReadValue("GameServer", "个人状态7").Trim();
				text = "个人状态8";
				个人状态8 = Config.IniReadValue("GameServer", "个人状态8").Trim();
				text = "个人状态9";
				个人状态9 = Config.IniReadValue("GameServer", "个人状态9").Trim();
				text = "异口同声是否开启";
				异口同声是否开启 = int.Parse(Config.IniReadValue("GameServer", "异口同声是否开启").Trim());
				text = "异口同声开启小时";
				异口同声开启小时 = int.Parse(Config.IniReadValue("GameServer", "异口同声开启小时").Trim());
				text = "异口同声开启分";
				异口同声开启分 = int.Parse(Config.IniReadValue("GameServer", "异口同声开启分").Trim());
				text = "异口同声开启秒";
				异口同声开启秒 = int.Parse(Config.IniReadValue("GameServer", "异口同声开启秒").Trim());
				text = "异口同声经验";
				异口同声经验 = double.Parse(Config.IniReadValue("GameServer", "异口同声经验").Trim());
				text = "异口同声爆率";
				异口同声爆率 = double.Parse(Config.IniReadValue("GameServer", "异口同声爆率").Trim());
				text = "异口同声攻击";
				异口同声攻击 = int.Parse(Config.IniReadValue("GameServer", "异口同声攻击").Trim());
				text = "异口同声防御";
				异口同声防御 = int.Parse(Config.IniReadValue("GameServer", "异口同声防御").Trim());
				text = "异口同声血量";
				异口同声血量 = int.Parse(Config.IniReadValue("GameServer", "异口同声血量").Trim());
				text = "异口同声蓝值";
				异口同声蓝值 = int.Parse(Config.IniReadValue("GameServer", "异口同声蓝值").Trim());
				text = "异口同声气功";
				异口同声气功 = int.Parse(Config.IniReadValue("GameServer", "异口同声气功").Trim());
				text = "异口同声结束时间";
				异口同声结束时间 = int.Parse(Config.IniReadValue("GameServer", "异口同声结束时间").Trim());
				text = "异口同声内容";
				异口同声内容 = ((Config.IniReadValue("GameServer", "异口同声内容").Trim() == "") ? 异口同声内容 : Config.IniReadValue("GameServer", "异口同声内容").Trim());
				text = "是否开启五转";
				是否开启五转 = int.Parse(Config.IniReadValue("GameServer", "是否开启五转").Trim());
				text = "门甲组合消耗类型";
				门甲组合消耗类型 = ((!(Config.IniReadValue("GameServer", "门甲组合消耗类型").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门甲组合消耗类型").Trim()) : 0);
				text = "门甲组合消耗的数量";
				门甲组合消耗的数量 = ((!(Config.IniReadValue("GameServer", "门甲组合消耗的数量").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "门甲组合消耗的数量").Trim()) : 0);
				text = "水晶符成功加等级";
				水晶符成功加等级 = int.Parse(Config.IniReadValue("GameServer", "水晶符成功加等级").Trim());
				text = "金刚守护符和寒玉守护符相关配置";
				金刚守护符和寒玉守护符相关配置 = int.Parse(Config.IniReadValue("GameServer", "金刚守护符和寒玉守护符相关配置").Trim());
				text = "金刚和寒玉守护符失败掉等级";
				金刚和寒玉守护符失败掉等级 = int.Parse(Config.IniReadValue("GameServer", "金刚和寒玉守护符失败掉等级").Trim());
				text = "水晶符相关配置";
				水晶符相关配置 = int.Parse(Config.IniReadValue("GameServer", "水晶符相关配置").Trim());
				text = "水晶符失败掉等级";
				水晶符失败掉等级 = int.Parse(Config.IniReadValue("GameServer", "水晶符失败掉等级").Trim());
				text = "江湖快报强化阶段";
				江湖快报强化阶段 = int.Parse(Config.IniReadValue("GameServer", "江湖快报强化阶段").Trim());
				text = "江湖快报内容";
				江湖快报内容 = Config.IniReadValue("GameServer", "江湖快报内容").Trim();
				text = "江湖快报内容一属性";
				江湖快报内容一属性 = Config.IniReadValue("GameServer", "江湖快报内容一属性").Trim();
				text = "江湖快报内容二属性";
				江湖快报内容二属性 = Config.IniReadValue("GameServer", "江湖快报内容二属性").Trim();
				text = "江湖快报内容三属性";
				江湖快报内容三属性 = Config.IniReadValue("GameServer", "江湖快报内容三属性").Trim();
				text = "江湖快报内容四属性";
				江湖快报内容四属性 = Config.IniReadValue("GameServer", "江湖快报内容四属性").Trim();
				text = "强化一合成率";
				强化一合成率 = ((Config.IniReadValue("GameServer", "强化一合成率") == "") ? 强化一合成率 : double.Parse(Config.IniReadValue("GameServer", "强化一合成率")));
				text = "强化二合成率";
				强化二合成率 = ((Config.IniReadValue("GameServer", "强化二合成率") == "") ? 强化二合成率 : double.Parse(Config.IniReadValue("GameServer", "强化二合成率")));
				text = "强化三合成率";
				强化三合成率 = ((Config.IniReadValue("GameServer", "强化三合成率") == "") ? 强化三合成率 : double.Parse(Config.IniReadValue("GameServer", "强化三合成率")));
				text = "强化四合成率";
				强化四合成率 = ((Config.IniReadValue("GameServer", "强化四合成率") == "") ? 强化四合成率 : double.Parse(Config.IniReadValue("GameServer", "强化四合成率")));
				text = "强化五合成率";
				强化五合成率 = ((Config.IniReadValue("GameServer", "强化五合成率") == "") ? 强化五合成率 : double.Parse(Config.IniReadValue("GameServer", "强化五合成率")));
				text = "强化六合成率";
				强化六合成率 = ((Config.IniReadValue("GameServer", "强化六合成率") == "") ? 强化六合成率 : double.Parse(Config.IniReadValue("GameServer", "强化六合成率")));
				text = "强化七合成率";
				强化七合成率 = ((Config.IniReadValue("GameServer", "强化七合成率") == "") ? 强化七合成率 : double.Parse(Config.IniReadValue("GameServer", "强化七合成率")));
				text = "强化八合成率";
				强化八合成率 = ((Config.IniReadValue("GameServer", "强化八合成率") == "") ? 强化八合成率 : double.Parse(Config.IniReadValue("GameServer", "强化八合成率")));
				text = "强化九合成率";
				强化九合成率 = ((Config.IniReadValue("GameServer", "强化九合成率") == "") ? 强化九合成率 : double.Parse(Config.IniReadValue("GameServer", "强化九合成率")));
				text = "强化十合成率";
				强化十合成率 = ((Config.IniReadValue("GameServer", "强化十合成率") == "") ? 强化十合成率 : double.Parse(Config.IniReadValue("GameServer", "强化十合成率")));
				text = "属性阶段一合成率";
				属性阶段一合成率 = ((Config.IniReadValue("GameServer", "属性阶段一合成率") == "") ? 属性阶段一合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段一合成率")));
				text = "属性阶段二合成率";
				属性阶段二合成率 = ((Config.IniReadValue("GameServer", "属性阶段二合成率") == "") ? 属性阶段二合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段二合成率")));
				text = "属性阶段三合成率";
				属性阶段三合成率 = ((Config.IniReadValue("GameServer", "属性阶段三合成率") == "") ? 属性阶段三合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段三合成率")));
				text = "属性阶段四合成率";
				属性阶段四合成率 = ((Config.IniReadValue("GameServer", "属性阶段四合成率") == "") ? 属性阶段四合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段四合成率")));
				text = "属性阶段五合成率";
				属性阶段五合成率 = ((Config.IniReadValue("GameServer", "属性阶段五合成率") == "") ? 属性阶段五合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段五合成率")));
				text = "属性阶段六合成率";
				属性阶段六合成率 = ((Config.IniReadValue("GameServer", "属性阶段六合成率") == "") ? 属性阶段六合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段六合成率")));
				text = "属性阶段七合成率";
				属性阶段七合成率 = ((Config.IniReadValue("GameServer", "属性阶段七合成率") == "") ? 属性阶段七合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段七合成率")));
				text = "属性阶段八合成率";
				属性阶段八合成率 = ((Config.IniReadValue("GameServer", "属性阶段八合成率") == "") ? 属性阶段八合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段八合成率")));
				text = "属性阶段九合成率";
				属性阶段九合成率 = ((Config.IniReadValue("GameServer", "属性阶段九合成率") == "") ? 属性阶段九合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段九合成率")));
				text = "属性阶段十合成率";
				属性阶段十合成率 = ((Config.IniReadValue("GameServer", "属性阶段十合成率") == "") ? 属性阶段八合成率 : double.Parse(Config.IniReadValue("GameServer", "属性阶段十合成率")));
				text = "合成属性一合成率";
				合成属性一合成率 = ((Config.IniReadValue("GameServer", "合成属性一合成率") == "") ? 合成属性一合成率 : double.Parse(Config.IniReadValue("GameServer", "合成属性一合成率")));
				text = "合成属性二合成率";
				合成属性二合成率 = ((Config.IniReadValue("GameServer", "合成属性二合成率") == "") ? 合成属性二合成率 : double.Parse(Config.IniReadValue("GameServer", "合成属性二合成率")));
				text = "合成属性三合成率";
				合成属性三合成率 = ((Config.IniReadValue("GameServer", "合成属性三合成率") == "") ? 合成属性三合成率 : double.Parse(Config.IniReadValue("GameServer", "合成属性三合成率")));
				text = "合成属性四合成率";
				合成属性四合成率 = ((Config.IniReadValue("GameServer", "合成属性四合成率") == "") ? 合成属性四合成率 : double.Parse(Config.IniReadValue("GameServer", "合成属性四合成率")));
				text = "寄售元宝消费提示";
				寄售元宝消费提示 = Config.IniReadValue("GameServer", "寄售元宝消费提示").Trim();
				text = "元宝消费开启提示";
				元宝消费开启提示 = int.Parse(Config.IniReadValue("GameServer", "元宝消费开启提示").Trim());
				text = "元宝消费提示";
				元宝消费提示 = Config.IniReadValue("GameServer", "元宝消费提示").Trim();
				text = "积分消费开启提示";
				积分消费开启提示 = int.Parse(Config.IniReadValue("GameServer", "积分消费开启提示").Trim());
				text = "积分消费提示";
				积分消费提示 = Config.IniReadValue("GameServer", "积分消费提示").Trim();
				text = "追杀系统是否开放";
				追杀系统是否开放 = ((Config.IniReadValue("GameServer", "追杀系统是否开放").Trim() == "") ? 追杀系统是否开放 : int.Parse(Config.IniReadValue("GameServer", "追杀系统是否开放").Trim()));
				text = "玩家追踪命令";
				玩家追踪命令 = Config.IniReadValue("GameServer", "玩家追踪命令").Trim();
				text = "追踪玩家需要元宝数量";
				追踪玩家需要元宝数量 = int.Parse(Config.IniReadValue("GameServer", "追踪玩家需要元宝数量").Trim());
				text = "防追杀所需物品ID";
				防追杀所需物品ID = Config.IniReadValue("GameServer", "防追杀所需物品ID").Trim();
				text = "特殊地图";
				特殊地图 = Config.IniReadValue("GameServer", "特殊地图").Trim();
				text = "特殊地图限制时间";
				特殊地图限制时间 = Config.IniReadValue("GameServer", "特殊地图限制时间").Trim().Split(',');
				text = "特殊地图武勋倍数";
				特殊地图武勋倍数 = int.Parse(Config.IniReadValue("GameServer", "特殊地图武勋倍数").Trim());
				text = "杀人王奖励";
				杀人王奖励 = Config.IniReadValue("GameServer", "杀人王奖励").Trim();
				text = "杀人王数量";
				杀人王数量 = int.Parse(Config.IniReadValue("GameServer", "杀人王数量").Trim());
				text = "全服杀人提示";
				全服杀人提示 = Config.IniReadValue("GameServer", "全服杀人提示").Trim();
				text = "死亡全服公告是否开启";
				死亡全服公告是否开启 = int.Parse(Config.IniReadValue("GameServer", "死亡全服公告是否开启").Trim());
				text = "死亡播报次数";
				死亡播报次数 = int.Parse(Config.IniReadValue("GameServer", "死亡播报次数").Trim());
				text = "七彩提示是否开启";
				七彩提示是否开启 = ((!(Config.IniReadValue("GameServer", "七彩提示是否开启").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "七彩提示是否开启").Trim()) : 0);
				text = "红色提示内容";
				红色提示内容 = Config.IniReadValue("GameServer", "红色提示内容").Trim();
				text = "赤色提示内容";
				赤色提示内容 = Config.IniReadValue("GameServer", "赤色提示内容").Trim();
				text = "橙色提示内容";
				橙色提示内容 = Config.IniReadValue("GameServer", "橙色提示内容").Trim();
				text = "绿色提示内容";
				绿色提示内容 = Config.IniReadValue("GameServer", "绿色提示内容").Trim();
				text = "蓝色提示内容";
				蓝色提示内容 = Config.IniReadValue("GameServer", "蓝色提示内容").Trim();
				text = "深蓝提示内容";
				深蓝提示内容 = Config.IniReadValue("GameServer", "深蓝提示内容").Trim();
				text = "紫色提示内容";
				紫色提示内容 = Config.IniReadValue("GameServer", "紫色提示内容").Trim();
				text = "七彩加属性";
				七彩加属性 = Config.IniReadValue("GameServer", "七彩加属性").Trim();
				text = "刷武勋BOSS开关";
				刷武勋BOSS开关 = int.Parse(Config.IniReadValue("GameServer", "刷武勋BOSS开关").Trim());
				text = "刷元宝BOSS开关";
				刷元宝BOSS开关 = int.Parse(Config.IniReadValue("GameServer", "刷元宝BOSS开关").Trim());
				text = "刷积分BOSS开关";
				刷积分BOSS开关 = int.Parse(Config.IniReadValue("GameServer", "刷积分BOSS开关").Trim());
				text = "刷金币BOSS开关";
				刷金币BOSS开关 = int.Parse(Config.IniReadValue("GameServer", "刷金币BOSS开关").Trim());
				text = "刷武勋BOSS开关1";
				刷武勋BOSS开关1 = int.Parse(Config.IniReadValue("GameServer", "刷武勋BOSS开关1").Trim());
				text = "刷元宝BOSS开关1";
				刷元宝BOSS开关1 = int.Parse(Config.IniReadValue("GameServer", "刷元宝BOSS开关1").Trim());
				text = "刷积分BOSS开关1";
				刷积分BOSS开关1 = int.Parse(Config.IniReadValue("GameServer", "刷积分BOSS开关1").Trim());
				text = "刷金币BOSS开关1";
				刷金币BOSS开关1 = int.Parse(Config.IniReadValue("GameServer", "刷金币BOSS开关1").Trim());
				text = "删除BOSS时间二";
				删除BOSS时间二 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时间二").Trim());
				text = "删除BOSS时分二";
				删除BOSS时分二 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时分二").Trim());
				text = "删除BOSS时秒二";
				删除BOSS时秒二 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时秒二").Trim());
				text = "刷新BOSS时间二";
				刷新BOSS时间二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时间二").Trim());
				text = "刷新BOSS时分二";
				刷新BOSS时分二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时分二").Trim());
				text = "刷新BOSS时秒二";
				刷新BOSS时秒二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时秒二").Trim());
				text = "刷新BOSS怪物ID一二";
				刷新BOSS怪物ID一二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID一二").Trim());
				text = "刷新BOSS怪物ID二二";
				刷新BOSS怪物ID二二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID二二").Trim());
				text = "刷新BOSS怪物ID三二";
				刷新BOSS怪物ID三二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID三二").Trim());
				text = "刷新BOSS怪物ID四二";
				刷新BOSS怪物ID四二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID四二").Trim());
				text = "刷新BOSS所在地图ID二";
				刷新BOSS所在地图ID二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS所在地图ID二").Trim());
				text = "刷新BOSS提示内容一二";
				刷新BOSS提示内容一二 = Config.IniReadValue("GameServer", "刷新BOSS提示内容一二").Trim();
				text = "刷新BOSS提示内容二二";
				刷新BOSS提示内容二二 = Config.IniReadValue("GameServer", "刷新BOSS提示内容二二").Trim();
				text = "刷新BOSS提示内容三二";
				刷新BOSS提示内容三二 = Config.IniReadValue("GameServer", "刷新BOSS提示内容三二").Trim();
				text = "刷新BOSS提示内容四二";
				刷新BOSS提示内容四二 = Config.IniReadValue("GameServer", "刷新BOSS提示内容四二").Trim();
				text = "删除BOSS时间一";
				删除BOSS时间一 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时间一").Trim());
				text = "删除BOSS时分一";
				删除BOSS时分一 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时分一").Trim());
				text = "删除BOSS时秒一";
				删除BOSS时秒一 = int.Parse(Config.IniReadValue("GameServer", "删除BOSS时秒一").Trim());
				text = "刷新BOSS时间一";
				刷新BOSS时间一 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时间一").Trim());
				text = "刷新BOSS时分一";
				刷新BOSS时分一 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时分一").Trim());
				text = "刷新BOSS时秒一";
				刷新BOSS时秒一 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS时秒一").Trim());
				text = "刷新BOSS怪物ID一";
				刷新BOSS怪物ID一 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID一").Trim());
				text = "刷新BOSS怪物ID二";
				刷新BOSS怪物ID二 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID二").Trim());
				text = "刷新BOSS怪物ID三";
				刷新BOSS怪物ID三 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID三").Trim());
				text = "刷新BOSS怪物ID四";
				刷新BOSS怪物ID四 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS怪物ID四").Trim());
				text = "刷新BOSS所在地图ID一";
				刷新BOSS所在地图ID一 = int.Parse(Config.IniReadValue("GameServer", "刷新BOSS所在地图ID一").Trim());
				text = "刷新BOSS提示内容一";
				刷新BOSS提示内容一 = Config.IniReadValue("GameServer", "刷新BOSS提示内容一").Trim();
				text = "刷新BOSS提示内容二";
				刷新BOSS提示内容二 = Config.IniReadValue("GameServer", "刷新BOSS提示内容二").Trim();
				text = "刷新BOSS提示内容三";
				刷新BOSS提示内容三 = Config.IniReadValue("GameServer", "刷新BOSS提示内容三").Trim();
				text = "刷新BOSS提示内容四";
				刷新BOSS提示内容四 = Config.IniReadValue("GameServer", "刷新BOSS提示内容四").Trim();
				text = "是否开启提示刷新BOSS坐标";
				是否开启提示刷新BOSS坐标 = int.Parse(Config.IniReadValue("GameServer", "是否开启提示刷新BOSS坐标").Trim());
				text = "是否开启世界随机BOSS一";
				是否开启世界随机BOSS一 = int.Parse(Config.IniReadValue("GameServer", "是否开启世界随机BOSS一").Trim());
				text = "是否开启世界随机BOSS二";
				是否开启世界随机BOSS二 = int.Parse(Config.IniReadValue("GameServer", "是否开启世界随机BOSS二").Trim());
				text = "PK系统地图";
				PK系统地图 = Config.IniReadValue("GameServer", "PK系统地图").Trim().Split(';');
				text = "获得胜利内容";
				获得胜利内容 = ((Config.IniReadValue("GameServer", "获得胜利内容").Trim() == "") ? 获得胜利内容 : Config.IniReadValue("GameServer", "获得胜利内容").Trim());
				text = "攻城战奖励类型";
				攻城战奖励类型 = int.Parse(Config.IniReadValue("GameServer", "攻城战奖励类型").Trim());
				text = "攻城战奖励属性";
				攻城战奖励属性 = Config.IniReadValue("GameServer", "攻城战奖励属性").Trim();
				text = "攻城战奖励物品";
				攻城战奖励物品 = Config.IniReadValue("GameServer", "攻城战奖励物品").Trim();
				text = "攻城战奖励套装";
				攻城战奖励套装 = int.Parse(Config.IniReadValue("GameServer", "攻城战奖励套装").Trim());
				text = "攻城战是否给增幅";
				攻城战是否给增幅 = int.Parse(Config.IniReadValue("GameServer", "攻城战是否给增幅").Trim());
				text = "攻城战增幅";
				攻城战增幅 = Config.IniReadValue("GameServer", "攻城战增幅").Trim();
				text = "攻城奖励地图";
				攻城奖励地图 = Config.IniReadValue("GameServer", "攻城奖励地图").Trim();
				text = "攻城战范围";
				攻城战范围 = int.Parse(Config.IniReadValue("GameServer", "攻城战范围").Trim());
				text = "攻城战X坐标";
				攻城战X坐标 = float.Parse(Config.IniReadValue("GameServer", "攻城战X坐标").Trim());
				text = "攻城战Y坐标";
				攻城战Y坐标 = float.Parse(Config.IniReadValue("GameServer", "攻城战Y坐标").Trim());
				text = "攻城战地图";
				攻城战地图 = int.Parse(Config.IniReadValue("GameServer", "攻城战地图").Trim());
				text = "攻城战开启小时";
				攻城战开启小时 = int.Parse(Config.IniReadValue("GameServer", "攻城战开启小时").Trim());
				text = "攻城战开启分";
				攻城战开启分 = int.Parse(Config.IniReadValue("GameServer", "攻城战开启分").Trim());
				text = "攻城战开启秒";
				攻城战开启秒 = int.Parse(Config.IniReadValue("GameServer", "攻城战开启秒").Trim());
				text = "攻城战是否开启";
				攻城战是否开启 = int.Parse(Config.IniReadValue("GameServer", "攻城战是否开启").Trim());
				text = "攻城战地图坐标";
				攻城战地图坐标 = Config.IniReadValue("GameServer", "攻城战地图坐标").Trim().Split(';');
				text = "攻城时间";
				攻城时间 = int.Parse(Config.IniReadValue("GameServer", "攻城时间").Trim());
				text = "攻城奖励时间天数";
				攻城奖励时间天数 = ((Config.IniReadValue("GameServer", "攻城奖励时间天数").Trim() == "") ? 攻城奖励时间天数 : int.Parse(Config.IniReadValue("GameServer", "攻城奖励时间天数").Trim()));
				text = "城主药品时间";
				城主药品时间 = int.Parse(Config.IniReadValue("GameServer", "城主药品时间").Trim());
				text = "成员药品时间";
				成员药品时间 = int.Parse(Config.IniReadValue("GameServer", "成员药品时间").Trim());
				text = "城主提示内容";
				城主提示内容 = Config.IniReadValue("GameServer", "城主提示内容").Trim();
				text = "成员提示内容";
				成员提示内容 = Config.IniReadValue("GameServer", "成员提示内容").Trim();
				text = "三阶转生副本需要元宝";
				三阶转生副本需要元宝 = ((Config.IniReadValue("GameServer", "三阶转生副本需要元宝").Trim() == "") ? 三阶转生副本需要元宝 : int.Parse(Config.IniReadValue("GameServer", "三阶转生副本需要元宝").Trim()));
				text = "三阶转生副本需要积分";
				三阶转生副本需要积分 = ((Config.IniReadValue("GameServer", "三阶转生副本需要积分").Trim() == "") ? 三阶转生副本需要积分 : int.Parse(Config.IniReadValue("GameServer", "三阶转生副本需要积分").Trim()));
				text = "三阶转生副本需要武勋";
				三阶转生副本需要武勋 = ((Config.IniReadValue("GameServer", "三阶转生副本需要武勋").Trim() == "") ? 三阶转生副本需要武勋 : int.Parse(Config.IniReadValue("GameServer", "三阶转生副本需要武勋").Trim()));
				text = "三阶转生副本需要金币";
				三阶转生副本需要金币 = ((Config.IniReadValue("GameServer", "三阶转生副本需要金币").Trim() == "") ? 三阶转生副本需要金币 : int.Parse(Config.IniReadValue("GameServer", "三阶转生副本需要金币").Trim()));
				text = "三阶转生副本转生限制";
				三阶转生副本转生限制 = int.Parse(Config.IniReadValue("GameServer", "三阶转生副本转生限制").Trim());
				text = "三阶转生副本是否开启";
				三阶转生副本是否开启 = int.Parse(Config.IniReadValue("GameServer", "三阶转生副本是否开启").Trim());
				text = "三阶转生副本移动命令";
				三阶转生副本移动命令 = Config.IniReadValue("GameServer", "三阶转生副本移动命令").Trim();
				text = "三阶转生副本地图ID";
				三阶转生副本地图ID = int.Parse(Config.IniReadValue("GameServer", "三阶转生副本地图ID").Trim());
				text = "三阶转生副本地图坐标X";
				三阶转生副本地图坐标X = float.Parse(Config.IniReadValue("GameServer", "三阶转生副本地图坐标X").Trim());
				text = "三阶转生副本地图坐标Y";
				三阶转生副本地图坐标Y = float.Parse(Config.IniReadValue("GameServer", "三阶转生副本地图坐标Y").Trim());
				text = "二阶转生副本需要元宝";
				二阶转生副本需要元宝 = ((Config.IniReadValue("GameServer", "二阶转生副本需要元宝").Trim() == "") ? 二阶转生副本需要元宝 : int.Parse(Config.IniReadValue("GameServer", "二阶转生副本需要元宝").Trim()));
				text = "二阶转生副本需要积分";
				二阶转生副本需要积分 = ((Config.IniReadValue("GameServer", "二阶转生副本需要积分").Trim() == "") ? 二阶转生副本需要积分 : int.Parse(Config.IniReadValue("GameServer", "二阶转生副本需要积分").Trim()));
				text = "二阶转生副本需要武勋";
				二阶转生副本需要武勋 = ((Config.IniReadValue("GameServer", "二阶转生副本需要武勋").Trim() == "") ? 二阶转生副本需要武勋 : int.Parse(Config.IniReadValue("GameServer", "二阶转生副本需要武勋").Trim()));
				text = "二阶转生副本需要金币";
				二阶转生副本需要金币 = ((Config.IniReadValue("GameServer", "二阶转生副本需要金币").Trim() == "") ? 二阶转生副本需要金币 : int.Parse(Config.IniReadValue("GameServer", "二阶转生副本需要金币").Trim()));
				text = "二阶转生副本转生限制";
				二阶转生副本转生限制 = int.Parse(Config.IniReadValue("GameServer", "二阶转生副本转生限制").Trim());
				text = "二阶转生副本是否开启";
				二阶转生副本是否开启 = int.Parse(Config.IniReadValue("GameServer", "二阶转生副本是否开启").Trim());
				text = "二阶转生副本移动命令";
				二阶转生副本移动命令 = Config.IniReadValue("GameServer", "二阶转生副本移动命令").Trim();
				text = "二阶转生副本地图ID";
				二阶转生副本地图ID = int.Parse(Config.IniReadValue("GameServer", "二阶转生副本地图ID").Trim());
				text = "二阶转生副本地图坐标X";
				二阶转生副本地图坐标X = float.Parse(Config.IniReadValue("GameServer", "二阶转生副本地图坐标X").Trim());
				text = "二阶转生副本地图坐标Y";
				二阶转生副本地图坐标Y = float.Parse(Config.IniReadValue("GameServer", "二阶转生副本地图坐标Y").Trim());
				text = "一阶转生副本需要元宝";
				一阶转生副本需要元宝 = ((Config.IniReadValue("GameServer", "一阶转生副本需要元宝").Trim() == "") ? 一阶转生副本需要元宝 : int.Parse(Config.IniReadValue("GameServer", "一阶转生副本需要元宝").Trim()));
				text = "一阶转生副本需要积分";
				一阶转生副本需要积分 = ((Config.IniReadValue("GameServer", "一阶转生副本需要积分").Trim() == "") ? 一阶转生副本需要积分 : int.Parse(Config.IniReadValue("GameServer", "一阶转生副本需要积分").Trim()));
				text = "一阶转生副本需要武勋";
				一阶转生副本需要武勋 = ((Config.IniReadValue("GameServer", "一阶转生副本需要武勋").Trim() == "") ? 一阶转生副本需要武勋 : int.Parse(Config.IniReadValue("GameServer", "一阶转生副本需要武勋").Trim()));
				text = "一阶转生副本需要金币";
				一阶转生副本需要金币 = ((Config.IniReadValue("GameServer", "一阶转生副本需要金币").Trim() == "") ? 一阶转生副本需要金币 : int.Parse(Config.IniReadValue("GameServer", "一阶转生副本需要金币").Trim()));
				text = "一阶转生副本转生限制";
				一阶转生副本转生限制 = int.Parse(Config.IniReadValue("GameServer", "一阶转生副本转生限制").Trim());
				text = "一阶转生副本是否开启";
				一阶转生副本是否开启 = int.Parse(Config.IniReadValue("GameServer", "一阶转生副本是否开启").Trim());
				text = "一阶转生副本移动命令";
				一阶转生副本移动命令 = Config.IniReadValue("GameServer", "一阶转生副本移动命令").Trim();
				text = "一阶转生副本地图ID";
				一阶转生副本地图ID = int.Parse(Config.IniReadValue("GameServer", "一阶转生副本地图ID").Trim());
				text = "一阶转生副本地图坐标X";
				一阶转生副本地图坐标X = float.Parse(Config.IniReadValue("GameServer", "一阶转生副本地图坐标X").Trim());
				text = "一阶转生副本地图坐标Y";
				一阶转生副本地图坐标Y = float.Parse(Config.IniReadValue("GameServer", "一阶转生副本地图坐标Y").Trim());
				text = "是否开启转生次数奖励";
				是否开启转生次数奖励 = int.Parse(Config.IniReadValue("GameServer", "是否开启转生次数奖励").Trim());
				text = "限制转生次数";
				限制转生次数 = int.Parse(Config.IniReadValue("GameServer", "限制转生次数").Trim());
				text = "转生需要几转";
				转生需要几转 = int.Parse(Config.IniReadValue("GameServer", "转生需要几转").Trim());
				text = "转生降落几转";
				转生降落几转 = int.Parse(Config.IniReadValue("GameServer", "转生降落几转").Trim());
				text = "转生需要等级";
				转生需要等级 = int.Parse(Config.IniReadValue("GameServer", "转生需要等级").Trim());
				text = "转生回落等级";
				转生回落等级 = int.Parse(Config.IniReadValue("GameServer", "转生回落等级").Trim());
				text = "转生奖励类型";
				转生奖励类型 = int.Parse(Config.IniReadValue("GameServer", "转生奖励类型").Trim());
				text = "转生奖励数量";
				转生奖励数量 = int.Parse(Config.IniReadValue("GameServer", "转生奖励数量").Trim());
				text = "转生获得属性";
				转生获得属性 = Config.IniReadValue("GameServer", "转生获得属性").Trim();
				text = "转生奖励物品";
				转生奖励物品 = Config.IniReadValue("GameServer", "转生奖励物品").Trim();
				text = "转生奖励套装";
				转生奖励套装 = int.Parse(Config.IniReadValue("GameServer", "转生奖励套装").Trim());
				text = "转生公告";
				转生公告 = int.Parse(Config.IniReadValue("GameServer", "转生公告").Trim());
				text = "转生公告内容";
				转生公告内容 = Config.IniReadValue("GameServer", "转生公告内容").Trim();
				text = "活动副本需要元宝";
				活动副本需要元宝 = ((Config.IniReadValue("GameServer", "活动副本需要元宝").Trim() == "") ? 活动副本需要元宝 : int.Parse(Config.IniReadValue("GameServer", "活动副本需要元宝").Trim()));
				text = "活动副本需要积分";
				活动副本需要积分 = ((Config.IniReadValue("GameServer", "活动副本需要积分").Trim() == "") ? 活动副本需要积分 : int.Parse(Config.IniReadValue("GameServer", "活动副本需要积分").Trim()));
				text = "活动副本需要武勋";
				活动副本需要武勋 = ((Config.IniReadValue("GameServer", "活动副本需要武勋").Trim() == "") ? 活动副本需要武勋 : int.Parse(Config.IniReadValue("GameServer", "活动副本需要武勋").Trim()));
				text = "活动副本需要金币";
				活动副本需要金币 = ((Config.IniReadValue("GameServer", "活动副本需要金币").Trim() == "") ? 活动副本需要金币 : int.Parse(Config.IniReadValue("GameServer", "活动副本需要金币").Trim()));
				text = "活动副本等级限制";
				活动副本等级限制 = int.Parse(Config.IniReadValue("GameServer", "活动副本等级限制").Trim());
				text = "活动副本是否开启";
				活动副本是否开启 = int.Parse(Config.IniReadValue("GameServer", "活动副本是否开启").Trim());
				text = "皇号福利命令";
				皇号福利命令 = Config.IniReadValue("GameServer", "皇号福利命令").Trim();
				text = "活动副本移动命令";
				活动副本移动命令 = Config.IniReadValue("GameServer", "活动副本移动命令").Trim();
				text = "活动副本地图ID";
				活动副本地图ID = int.Parse(Config.IniReadValue("GameServer", "活动副本地图ID").Trim());
				text = "活动副本地图坐标X";
				活动副本地图坐标X = float.Parse(Config.IniReadValue("GameServer", "活动副本地图坐标X").Trim());
				text = "活动副本地图坐标Y";
				活动副本地图坐标Y = float.Parse(Config.IniReadValue("GameServer", "活动副本地图坐标Y").Trim());
				text = "活动副本开启小时";
				活动副本开启小时 = int.Parse(Config.IniReadValue("GameServer", "活动副本开启小时").Trim());
				text = "活动副本开启分";
				活动副本开启分 = int.Parse(Config.IniReadValue("GameServer", "活动副本开启分").Trim());
				text = "活动副本结束小时";
				活动副本结束小时 = int.Parse(Config.IniReadValue("GameServer", "活动副本结束小时").Trim());
				text = "活动副本结束分";
				活动副本结束分 = int.Parse(Config.IniReadValue("GameServer", "活动副本结束分").Trim());
				text = "活动副本开启公告内容";
				活动副本开启公告内容 = Config.IniReadValue("GameServer", "活动副本开启公告内容").Trim();
				text = "活动副本结束公告内容";
				活动副本结束公告内容 = Config.IniReadValue("GameServer", "活动副本结束公告内容").Trim();
				text = "人物最大元宝数";
				人物最大元宝数 = ((Config.IniReadValue("GameServer", "人物最大元宝数").Trim() == "") ? 2000000000 : long.Parse(Config.IniReadValue("GameServer", "人物最大元宝数").Trim()));
				text = "皇号福利开关";
				皇号福利开关 = ((!(Config.IniReadValue("GameServer", "皇号福利开关").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "皇号福利开关").Trim()) : 0);
				text = "秘境副本移动命令";
				秘境副本移动命令 = Config.IniReadValue("GameServer", "秘境副本移动命令").Trim();
				text = "秘境挑战所需物品ID";
				秘境挑战所需物品ID = Config.IniReadValue("GameServer", " 秘境挑战所需物品ID").Trim();
				text = "秘境奖励类型";
				秘境奖励类型 = int.Parse(Config.IniReadValue("GameServer", "秘境奖励类型").Trim());
				text = "秘境奖励物品";
				秘境奖励物品 = Config.IniReadValue("GameServer", "秘境奖励物品").Trim();
				text = "秘境奖励属性";
				秘境奖励属性 = Config.IniReadValue("GameServer", "秘境奖励属性").Trim();
				text = "秘境人数";
				秘境人数 = ((!(Config.IniReadValue("GameServer", "秘境人数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境人数").Trim()) : 0);
				text = "秘境每日次数";
				秘境每日次数 = ((!(Config.IniReadValue("GameServer", "秘境每日次数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境每日次数").Trim()) : 0);
				text = "皇号福利每日次数";
				皇号福利每日次数 = ((!(Config.IniReadValue("GameServer", "皇号福利每日次数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "皇号福利每日次数").Trim()) : 0);
				text = "秘境开关";
				秘境开关 = ((!(Config.IniReadValue("GameServer", "秘境开关").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境开关").Trim()) : 0);
				text = "秘境限制等级";
				秘境限制等级 = ((!(Config.IniReadValue("GameServer", "秘境限制等级").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境限制等级").Trim()) : 0);
				text = "秘境重置时间";
				秘境重置时间 = ((!(Config.IniReadValue("GameServer", "秘境重置时间").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境重置时间").Trim()) : 0);
				text = "秘境重置时分";
				秘境重置时分 = ((!(Config.IniReadValue("GameServer", "秘境重置时分").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境重置时分").Trim()) : 0);
				text = "秘境第一波怪物ID";
				秘境第一波怪物ID = int.Parse(Config.IniReadValue("GameServer", "秘境第一波怪物ID").Trim());
				text = "秘境第一波怪物数量";
				秘境第一波怪物数量 = int.Parse(Config.IniReadValue("GameServer", "秘境第一波怪物数量").Trim());
				text = "秘境第一波怪物时间";
				秘境第一波怪物时间 = int.Parse(Config.IniReadValue("GameServer", "秘境第一波怪物时间").Trim());
				text = "秘境准备时间";
				秘境准备时间 = int.Parse(Config.IniReadValue("GameServer", "秘境准备时间").Trim());
				text = "秘境需要转生次数";
				秘境需要转生次数 = ((!(Config.IniReadValue("GameServer", "秘境需要转生次数").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "秘境需要转生次数").Trim()) : 0);
				text = "秘境第二波怪物ID";
				秘境第二波怪物ID = int.Parse(Config.IniReadValue("GameServer", "秘境第二波怪物ID").Trim());
				text = "秘境第二波怪物数量";
				秘境第二波怪物数量 = int.Parse(Config.IniReadValue("GameServer", "秘境第二波怪物数量").Trim());
				text = "秘境第二波怪物时间";
				秘境第二波怪物时间 = int.Parse(Config.IniReadValue("GameServer", "秘境第二波怪物时间").Trim());
				text = "秘境第三波怪物ID";
				秘境第三波怪物ID = int.Parse(Config.IniReadValue("GameServer", "秘境第三波怪物ID").Trim());
				text = "秘境第三波怪物数量";
				秘境第三波怪物数量 = int.Parse(Config.IniReadValue("GameServer", "秘境第三波怪物数量").Trim());
				text = "秘境第三波怪物时间";
				秘境第三波怪物时间 = int.Parse(Config.IniReadValue("GameServer", "秘境第三波怪物时间").Trim());
				text = "武勋保护等级";
				武勋保护等级 = int.Parse(Config.IniReadValue("GameServer", "武勋保护等级").Trim());
				text = "武勋保护数值";
				武勋保护数值 = int.Parse(Config.IniReadValue("GameServer", "武勋保护数值").Trim());
				text = "武勋保护命令";
				武勋保护命令 = Config.IniReadValue("GameServer", "武勋保护命令").Trim();
				text = "武勋保护删除命令";
				武勋保护删除命令 = Config.IniReadValue("GameServer", "武勋保护删除命令").Trim();
				text = "武勋保护需要元宝";
				武勋保护需要元宝 = ((!(Config.IniReadValue("GameServer", "武勋保护需要元宝").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "武勋保护需要元宝").Trim()) : 0);
				text = "忠诚度一阶段追加经验";
				忠诚度一阶段追加经验 = double.Parse(Config.IniReadValue("GameServer", "忠诚度一阶段追加经验").Trim());
				text = "忠诚度二阶段追加经验";
				忠诚度二阶段追加经验 = double.Parse(Config.IniReadValue("GameServer", "忠诚度二阶段追加经验").Trim());
				text = "忠诚度三阶段追加经验";
				忠诚度三阶段追加经验 = double.Parse(Config.IniReadValue("GameServer", "忠诚度三阶段追加经验").Trim());
				text = "忠诚度四阶段追加经验";
				忠诚度四阶段追加经验 = double.Parse(Config.IniReadValue("GameServer", "忠诚度四阶段追加经验").Trim());
				text = "宠物一转追加经验";
				宠物一转追加经验 = double.Parse(Config.IniReadValue("GameServer", "宠物一转追加经验").Trim());
				text = "宠物二转追加经验";
				宠物二转追加经验 = double.Parse(Config.IniReadValue("GameServer", "宠物二转追加经验").Trim());
				text = "宠物三转追加经验";
				宠物三转追加经验 = double.Parse(Config.IniReadValue("GameServer", "宠物三转追加经验").Trim());
				text = "忠诚度满追加暴率";
				忠诚度满追加暴率 = double.Parse(Config.IniReadValue("GameServer", "忠诚度满追加暴率").Trim());
				text = "龙猫追加暴率";
				龙猫追加暴率 = double.Parse(Config.IniReadValue("GameServer", "龙猫追加暴率").Trim());
				text = "羽雕追加暴率";
				羽雕追加暴率 = double.Parse(Config.IniReadValue("GameServer", "羽雕追加暴率").Trim());
				text = "豹子追加暴率";
				豹子追加暴率 = double.Parse(Config.IniReadValue("GameServer", "豹子追加暴率").Trim());
				text = "老虎追加暴率";
				老虎追加暴率 = double.Parse(Config.IniReadValue("GameServer", "老虎追加暴率").Trim());
				text = "龙猫追加经验";
				龙猫追加经验 = double.Parse(Config.IniReadValue("GameServer", "龙猫追加经验").Trim());
				text = "羽雕追加经验";
				羽雕追加经验 = double.Parse(Config.IniReadValue("GameServer", "羽雕追加经验").Trim());
				text = "豹子追加经验";
				豹子追加经验 = double.Parse(Config.IniReadValue("GameServer", "豹子追加经验").Trim());
				text = "老虎追加经验";
				老虎追加经验 = double.Parse(Config.IniReadValue("GameServer", "老虎追加经验").Trim());
				text = "是否开启宠物加成";
				是否开启宠物加成 = ((Config.IniReadValue("GameServer", "是否开启宠物加成").Trim() == "") ? 是否开启宠物加成 : int.Parse(Config.IniReadValue("GameServer", "是否开启宠物加成").Trim()));
				text = "宠物掉忠诚度数量";
				宠物掉忠诚度数量 = ((Config.IniReadValue("GameServer", "宠物掉忠诚度数量").Trim() == "") ? 宠物掉忠诚度数量 : int.Parse(Config.IniReadValue("GameServer", "宠物掉忠诚度数量").Trim()));
				text = "宠物掉忠诚间隔";
				宠物掉忠诚间隔 = ((Config.IniReadValue("GameServer", "宠物掉忠诚间隔").Trim() == "") ? 宠物掉忠诚间隔 : int.Parse(Config.IniReadValue("GameServer", "宠物掉忠诚间隔").Trim()));
				text = "武功防额外调整";
				武功防额外调整 = Config.IniReadValue("GameServer", "武功防额外调整").Trim().Split(';');
				text = "武功攻击额外调整";
				武功攻击额外调整 = Config.IniReadValue("GameServer", "武功攻击额外调整").Trim().Split(';');
				text = "积分BUFF是否开启";
				积分BUFF是否开启 = int.Parse(Config.IniReadValue("GameServer", "积分BUFF是否开启").Trim());
				text = "一阶段积分BUFF";
				一阶段积分BUFF = int.Parse(Config.IniReadValue("GameServer", "一阶段积分BUFF").Trim());
				text = "一阶段积分增加攻击";
				一阶段积分增加攻击 = int.Parse(Config.IniReadValue("GameServer", "一阶段积分增加攻击").Trim());
				text = "一阶段积分增加防御";
				一阶段积分增加防御 = int.Parse(Config.IniReadValue("GameServer", "一阶段积分增加防御").Trim());
				text = "一阶段积分增加血量";
				一阶段积分增加血量 = int.Parse(Config.IniReadValue("GameServer", "一阶段积分增加血量").Trim());
				text = "一阶段积分增加蓝量";
				一阶段积分增加蓝量 = int.Parse(Config.IniReadValue("GameServer", "一阶段积分增加蓝量").Trim());
				text = "一阶段积分增加经验百分比";
				一阶段积分增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "一阶段积分增加经验百分比").Trim());
				text = "一阶段积分增加爆率百分比";
				一阶段积分增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "一阶段积分增加爆率百分比").Trim());
				text = "一阶段积分增加合成强化百分比";
				一阶段积分增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "一阶段积分增加合成强化百分比").Trim());
				text = "二阶段积分BUFF";
				二阶段积分BUFF = int.Parse(Config.IniReadValue("GameServer", "二阶段积分BUFF").Trim());
				text = "二阶段积分增加攻击";
				二阶段积分增加攻击 = int.Parse(Config.IniReadValue("GameServer", "二阶段积分增加攻击").Trim());
				text = "二阶段积分增加防御";
				二阶段积分增加防御 = int.Parse(Config.IniReadValue("GameServer", "二阶段积分增加防御").Trim());
				text = "二阶段积分增加血量";
				二阶段积分增加血量 = int.Parse(Config.IniReadValue("GameServer", "二阶段积分增加血量").Trim());
				text = "二阶段积分增加蓝量";
				二阶段积分增加蓝量 = int.Parse(Config.IniReadValue("GameServer", "二阶段积分增加蓝量").Trim());
				text = "二阶段积分增加经验百分比";
				二阶段积分增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "二阶段积分增加经验百分比").Trim());
				text = "二阶段积分增加爆率百分比";
				二阶段积分增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "二阶段积分增加爆率百分比").Trim());
				text = "二阶段积分增加合成强化百分比";
				二阶段积分增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "二阶段积分增加合成强化百分比").Trim());
				text = "三阶段积分BUFF";
				三阶段积分BUFF = int.Parse(Config.IniReadValue("GameServer", "三阶段积分BUFF").Trim());
				text = "三阶段积分增加攻击";
				三阶段积分增加攻击 = int.Parse(Config.IniReadValue("GameServer", "三阶段积分增加攻击").Trim());
				text = "三阶段积分增加防御";
				三阶段积分增加防御 = int.Parse(Config.IniReadValue("GameServer", "三阶段积分增加防御").Trim());
				text = "三阶段积分增加血量";
				三阶段积分增加血量 = int.Parse(Config.IniReadValue("GameServer", "三阶段积分增加血量").Trim());
				text = "三阶段积分增加蓝量";
				三阶段积分增加蓝量 = int.Parse(Config.IniReadValue("GameServer", "三阶段积分增加蓝量").Trim());
				text = "三阶段积分增加经验百分比";
				三阶段积分增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "三阶段积分增加经验百分比").Trim());
				text = "三阶段积分增加爆率百分比";
				三阶段积分增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "三阶段积分增加爆率百分比").Trim());
				text = "三阶段积分增加合成强化百分比";
				三阶段积分增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "三阶段积分增加合成强化百分比").Trim());
				text = "四阶段积分BUFF";
				四阶段积分BUFF = int.Parse(Config.IniReadValue("GameServer", "四阶段积分BUFF").Trim());
				text = "四阶段积分增加攻击";
				四阶段积分增加攻击 = int.Parse(Config.IniReadValue("GameServer", "四阶段积分增加攻击").Trim());
				text = "四阶段积分增加防御";
				四阶段积分增加防御 = int.Parse(Config.IniReadValue("GameServer", "四阶段积分增加防御").Trim());
				text = "四阶段积分增加血量";
				四阶段积分增加血量 = int.Parse(Config.IniReadValue("GameServer", "四阶段积分增加血量").Trim());
				text = "四阶段积分增加蓝量";
				四阶段积分增加蓝量 = int.Parse(Config.IniReadValue("GameServer", "四阶段积分增加蓝量").Trim());
				text = "四阶段积分增加经验百分比";
				四阶段积分增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "四阶段积分增加经验百分比").Trim());
				text = "四阶段积分增加爆率百分比";
				四阶段积分增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "四阶段积分增加爆率百分比").Trim());
				text = "四阶段积分增加合成强化百分比";
				四阶段积分增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "四阶段积分增加合成强化百分比").Trim());
				text = "五阶段积分BUFF";
				五阶段积分BUFF = int.Parse(Config.IniReadValue("GameServer", "五阶段积分BUFF").Trim());
				text = "五阶段积分增加攻击";
				五阶段积分增加攻击 = int.Parse(Config.IniReadValue("GameServer", "五阶段积分增加攻击").Trim());
				text = "五阶段积分增加防御";
				五阶段积分增加防御 = int.Parse(Config.IniReadValue("GameServer", "五阶段积分增加防御").Trim());
				text = "五阶段积分增加血量";
				五阶段积分增加血量 = int.Parse(Config.IniReadValue("GameServer", "五阶段积分增加血量").Trim());
				text = "五阶段积分增加蓝量";
				五阶段积分增加蓝量 = int.Parse(Config.IniReadValue("GameServer", "五阶段积分增加蓝量").Trim());
				text = "五阶段积分增加经验百分比";
				五阶段积分增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "五阶段积分增加经验百分比").Trim());
				text = "五阶段积分增加爆率百分比";
				五阶段积分增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "五阶段积分增加爆率百分比").Trim());
				text = "五阶段积分增加合成强化百分比";
				五阶段积分增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "五阶段积分增加合成强化百分比").Trim());
				text = "爱情度BUFF是否开启";
				爱情度BUFF是否开启 = int.Parse(Config.IniReadValue("GameServer", "爱情度BUFF是否开启").Trim());
				text = "爱情度一阶段";
				爱情度一阶段 = int.Parse(Config.IniReadValue("GameServer", "爱情度一阶段").Trim());
				text = "爱情度一阶段攻击增加";
				爱情度一阶段攻击增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度一阶段攻击增加").Trim());
				text = "爱情度一阶段防御增加";
				爱情度一阶段防御增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度一阶段防御增加").Trim());
				text = "爱情度一阶段血量增加";
				爱情度一阶段血量增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度一阶段血量增加").Trim());
				text = "爱情度一阶段蓝值增加";
				爱情度一阶段蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度一阶段蓝值增加").Trim());
				text = "爱情度一阶增加经验百分比";
				爱情度一阶增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度一阶增加经验百分比").Trim());
				text = "爱情度一阶增加爆率百分比";
				爱情度一阶增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度一阶增加爆率百分比").Trim());
				text = "爱情度一阶增加合成强化百分比";
				爱情度一阶增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度一阶增加合成强化百分比").Trim());
				text = "爱情度二阶段";
				爱情度二阶段 = int.Parse(Config.IniReadValue("GameServer", "爱情度二阶段").Trim());
				text = "爱情度二阶段攻击增加";
				爱情度二阶段攻击增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度二阶段攻击增加").Trim());
				text = "爱情度二阶段防御增加";
				爱情度二阶段防御增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度二阶段防御增加").Trim());
				text = "爱情度二阶段血量增加";
				爱情度二阶段血量增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度二阶段血量增加").Trim());
				text = "爱情度二阶段蓝值增加";
				爱情度二阶段蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度二阶段蓝值增加").Trim());
				text = "爱情度二阶增加经验百分比";
				爱情度二阶增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度二阶增加经验百分比").Trim());
				text = "爱情度二阶增加爆率百分比";
				爱情度二阶增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度二阶增加爆率百分比").Trim());
				text = "爱情度二阶增加合成强化百分比";
				爱情度二阶增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度二阶增加合成强化百分比").Trim());
				text = "爱情度三阶段";
				爱情度三阶段 = int.Parse(Config.IniReadValue("GameServer", "爱情度三阶段").Trim());
				text = "爱情度三阶段攻击增加";
				爱情度三阶段攻击增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度三阶段攻击增加").Trim());
				text = "爱情度三阶段防御增加";
				爱情度三阶段防御增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度三阶段防御增加").Trim());
				text = "爱情度三阶段血量增加";
				爱情度三阶段血量增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度三阶段血量增加").Trim());
				text = "爱情度三阶段蓝值增加";
				爱情度三阶段蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度三阶段蓝值增加").Trim());
				text = "爱情度三阶增加经验百分比";
				爱情度三阶增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度三阶增加经验百分比").Trim());
				text = "爱情度三阶增加爆率百分比";
				爱情度三阶增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度三阶增加爆率百分比").Trim());
				text = "爱情度三阶增加合成强化百分比";
				爱情度三阶增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度三阶增加合成强化百分比").Trim());
				text = "爱情度四阶段";
				爱情度四阶段 = int.Parse(Config.IniReadValue("GameServer", "爱情度四阶段").Trim());
				text = "爱情度四阶段攻击增加";
				爱情度四阶段攻击增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度四阶段攻击增加").Trim());
				text = "爱情度四阶段防御增加";
				爱情度四阶段防御增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度四阶段防御增加").Trim());
				text = "爱情度四阶段血量增加";
				爱情度四阶段血量增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度四阶段血量增加").Trim());
				text = "爱情度四阶段蓝值增加";
				爱情度四阶段蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度四阶段蓝值增加").Trim());
				text = "爱情度四阶增加经验百分比";
				爱情度四阶增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度四阶增加经验百分比").Trim());
				text = "爱情度四阶增加爆率百分比";
				爱情度四阶增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度四阶增加爆率百分比").Trim());
				text = "爱情度四阶增加合成强化百分比";
				爱情度四阶增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度四阶增加合成强化百分比").Trim());
				text = "爱情度五阶段";
				爱情度五阶段 = int.Parse(Config.IniReadValue("GameServer", "爱情度五阶段").Trim());
				text = "爱情度五阶段攻击增加";
				爱情度五阶段攻击增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度五阶段攻击增加").Trim());
				text = "爱情度五阶段防御增加";
				爱情度五阶段防御增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度五阶段防御增加").Trim());
				text = "爱情度五阶段血量增加";
				爱情度五阶段血量增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度五阶段血量增加").Trim());
				text = "爱情度五阶段蓝值增加";
				爱情度五阶段蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "爱情度五阶段蓝值增加").Trim());
				text = "爱情度五阶增加经验百分比";
				爱情度五阶增加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度五阶增加经验百分比").Trim());
				text = "爱情度五阶增加爆率百分比";
				爱情度五阶增加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度五阶增加爆率百分比").Trim());
				text = "爱情度五阶增加合成强化百分比";
				爱情度五阶增加合成强化百分比 = double.Parse(Config.IniReadValue("GameServer", "爱情度五阶增加合成强化百分比").Trim());
				text = "妖花增加经验百分比";
				妖花增加经验百分比 = ((Config.IniReadValue("GameServer", "妖花增加经验百分比") == "") ? 妖花增加经验百分比 : double.Parse(Config.IniReadValue("GameServer", "妖花增加经验百分比")));
				text = "妖花增加概率百分比";
				妖花增加概率百分比 = ((Config.IniReadValue("GameServer", "妖花增加概率百分比") == "") ? 妖花增加概率百分比 : double.Parse(Config.IniReadValue("GameServer", "妖花增加概率百分比")));
				text = "妖花增加血量";
				妖花增加血量 = ((!(Config.IniReadValue("GameServer", "妖花增加血量").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "妖花增加血量").Trim()) : 0);
				text = "妖花增加攻击力";
				妖花增加攻击力 = ((!(Config.IniReadValue("GameServer", "妖花增加攻击力").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "妖花增加攻击力").Trim()) : 0);
				text = "妖花增加防御";
				妖花增加防御 = ((!(Config.IniReadValue("GameServer", "妖花增加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "妖花增加防御").Trim()) : 0);
				text = "妖花增加武功百分比";
				妖花增加武功百分比 = ((Config.IniReadValue("GameServer", "妖花增加武功百分比") == "") ? 妖花增加武功百分比 : double.Parse(Config.IniReadValue("GameServer", "妖花增加武功百分比")));
				text = "妖花增加武功防御百分比";
				妖花增加武功防御百分比 = ((Config.IniReadValue("GameServer", "妖花增加武功防御百分比") == "") ? 妖花增加武功防御百分比 : double.Parse(Config.IniReadValue("GameServer", "妖花增加武功防御百分比")));
				text = "新手上线奖励是否开启";
				新手上线奖励是否开启 = int.Parse(Config.IniReadValue("GameServer", "新手上线奖励是否开启").Trim());
				text = "新手上线奖励";
				新手上线奖励 = Config.IniReadValue("GameServer", "新手上线奖励").Trim();
				text = "北海武器经验加成";
				北海武器经验加成 = double.Parse(Config.IniReadValue("GameServer", "北海武器经验加成").Trim());
				text = "北海武器气功加成";
				北海武器气功加成 = int.Parse(Config.IniReadValue("GameServer", "北海武器气功加成").Trim());
				text = "攻击元宝BOSS一阶段奖励";
				攻击元宝BOSS一阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS一阶段奖励").Trim());
				text = "攻击元宝BOSS一阶段伤害";
				攻击元宝BOSS一阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS一阶段伤害").Trim());
				text = "攻击元宝BOSS二阶段奖励";
				攻击元宝BOSS二阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS二阶段奖励").Trim());
				text = "攻击元宝BOSS二阶段伤害";
				攻击元宝BOSS二阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS二阶段伤害").Trim());
				text = "攻击元宝BOSS三阶段奖励";
				攻击元宝BOSS三阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS三阶段奖励").Trim());
				text = "攻击元宝BOSS三阶段伤害";
				攻击元宝BOSS三阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击元宝BOSS三阶段伤害").Trim());
				text = "攻击积分BOSS一阶段奖励";
				攻击积分BOSS一阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS一阶段奖励").Trim());
				text = "攻击积分BOSS一阶段伤害";
				攻击积分BOSS一阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS一阶段伤害").Trim());
				text = "攻击积分BOSS二阶段奖励";
				攻击积分BOSS二阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS二阶段奖励").Trim());
				text = "攻击积分BOSS二阶段伤害";
				攻击积分BOSS二阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS二阶段伤害").Trim());
				text = "攻击积分BOSS三阶段奖励";
				攻击积分BOSS三阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS三阶段奖励").Trim());
				text = "攻击积分BOSS三阶段伤害";
				攻击积分BOSS三阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击积分BOSS三阶段伤害").Trim());
				text = "攻击武勋BOSS一阶段奖励";
				攻击武勋BOSS一阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS一阶段奖励").Trim());
				text = "攻击武勋BOSS一阶段伤害";
				攻击武勋BOSS一阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS一阶段伤害").Trim());
				text = "攻击武勋BOSS二阶段奖励";
				攻击武勋BOSS二阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS二阶段奖励").Trim());
				text = "攻击武勋BOSS二阶段伤害";
				攻击武勋BOSS二阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS二阶段伤害").Trim());
				text = "攻击武勋BOSS三阶段奖励";
				攻击武勋BOSS三阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS三阶段奖励").Trim());
				text = "攻击武勋BOSS三阶段伤害";
				攻击武勋BOSS三阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击武勋BOSS三阶段伤害").Trim());
				text = "攻击金币BOSS一阶段奖励";
				攻击金币BOSS一阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS一阶段奖励").Trim());
				text = "攻击金币BOSS一阶段伤害";
				攻击金币BOSS一阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS一阶段伤害").Trim());
				text = "攻击金币BOSS二阶段奖励";
				攻击金币BOSS二阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS二阶段奖励").Trim());
				text = "攻击金币BOSS二阶段伤害";
				攻击金币BOSS二阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS二阶段伤害").Trim());
				text = "攻击金币BOSS三阶段奖励";
				攻击金币BOSS三阶段奖励 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS三阶段奖励").Trim());
				text = "攻击金币BOSS三阶段伤害";
				攻击金币BOSS三阶段伤害 = int.Parse(Config.IniReadValue("GameServer", "攻击金币BOSS三阶段伤害").Trim());
				text = "耳环重造最高属性";
				耳环重造最高属性 = Config.IniReadValue("GameServer", "耳环重造最高属性").Trim();
				text = "耳环重造需要元宝数";
				耳环重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "耳环重造需要元宝数").Trim());
				text = "耳环重造需要积分数";
				耳环重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "耳环重造需要积分数").Trim());
				text = "耳环重造需要武勋数";
				耳环重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "耳环重造需要武勋数").Trim());
				text = "耳环重造需要金币数";
				耳环重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "耳环重造需要金币数").Trim());
				text = "戒指重造最高属性";
				戒指重造最高属性 = Config.IniReadValue("GameServer", "戒指重造最高属性").Trim();
				text = "戒指重造需要元宝数";
				戒指重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "戒指重造需要元宝数").Trim());
				text = "戒指重造需要积分数";
				戒指重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "戒指重造需要积分数").Trim());
				text = "戒指重造需要武勋数";
				戒指重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "戒指重造需要武勋数").Trim());
				text = "戒指重造需要金币数";
				戒指重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "戒指重造需要金币数").Trim());
				text = "项链重造最高属性";
				项链重造最高属性 = Config.IniReadValue("GameServer", "项链重造最高属性").Trim();
				text = "项链重造需要元宝数";
				项链重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "项链重造需要元宝数").Trim());
				text = "项链重造需要积分数";
				项链重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "项链重造需要积分数").Trim());
				text = "项链重造需要武勋数";
				项链重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "项链重造需要武勋数").Trim());
				text = "项链重造需要金币数";
				项链重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "项链重造需要金币数").Trim());
				text = "咕咕鸡重造最高属性";
				咕咕鸡重造最高属性 = Config.IniReadValue("GameServer", "咕咕鸡重造最高属性").Trim();
				text = "咕咕鸡最高攻击";
				咕咕鸡最高攻击 = int.Parse(Config.IniReadValue("GameServer", "咕咕鸡最高攻击").Trim());
				text = "咕咕鸡重造需要积分数";
				咕咕鸡重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "咕咕鸡重造需要积分数").Trim());
				text = "咕咕鸡重造需要武勋数";
				咕咕鸡重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "咕咕鸡重造需要武勋数").Trim());
				text = "咕咕鸡重造需要金币数";
				咕咕鸡重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "咕咕鸡重造需要金币数").Trim());
				text = "老虎重造最高属性";
				老虎重造最高属性 = Config.IniReadValue("GameServer", "老虎重造最高属性").Trim();
				text = "老虎重造需要元宝数";
				老虎重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "老虎重造需要元宝数").Trim());
				text = "老虎重造需要积分数";
				老虎重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "老虎重造需要积分数").Trim());
				text = "老虎重造需要武勋数";
				老虎重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "老虎重造需要武勋数").Trim());
				text = "老虎重造需要金币数";
				老虎重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "老虎重造需要金币数").Trim());
				text = "豹子重造最高属性";
				豹子重造最高属性 = Config.IniReadValue("GameServer", "豹子重造最高属性").Trim();
				text = "豹子重造需要元宝数";
				豹子重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "豹子重造需要元宝数").Trim());
				text = "豹子重造需要积分数";
				豹子重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "豹子重造需要积分数").Trim());
				text = "豹子重造需要武勋数";
				豹子重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "豹子重造需要武勋数").Trim());
				text = "豹子重造需要金币数";
				豹子重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "豹子重造需要金币数").Trim());
				text = "雪雕重造最高属性";
				雪雕重造最高属性 = Config.IniReadValue("GameServer", "雪雕重造最高属性").Trim();
				text = "雪雕重造需要元宝数";
				雪雕重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "雪雕重造需要元宝数").Trim());
				text = "雪雕重造需要积分数";
				雪雕重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "雪雕重造需要积分数").Trim());
				text = "雪雕重造需要武勋数";
				雪雕重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "雪雕重造需要武勋数").Trim());
				text = "雪雕重造需要金币数";
				雪雕重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "雪雕重造需要金币数").Trim());
				text = "龙猫重造最高属性";
				龙猫重造最高属性 = Config.IniReadValue("GameServer", "龙猫重造最高属性").Trim();
				text = "龙猫重造需要元宝数";
				龙猫重造需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "龙猫重造需要元宝数").Trim());
				text = "龙猫重造需要积分数";
				龙猫重造需要积分数 = int.Parse(Config.IniReadValue("GameServer", "龙猫重造需要积分数").Trim());
				text = "龙猫重造需要武勋数";
				龙猫重造需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "龙猫重造需要武勋数").Trim());
				text = "龙猫重造需要金币数";
				龙猫重造需要金币数 = int.Parse(Config.IniReadValue("GameServer", "龙猫重造需要金币数").Trim());
				text = "披风强化每一阶段增加防御";
				披风强化每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "披风强化每一阶段增加防御").Trim());
				text = "披风强化每一阶段增加攻击";
				披风强化每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "披风强化每一阶段增加攻击").Trim());
				text = "披风强化每一阶段增加生命";
				披风强化每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "披风强化每一阶段增加生命").Trim());
				text = "披风强化每一阶段增加蓝值";
				披风强化每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "披风强化每一阶段增加蓝值").Trim());
				text = "披风强化每一阶段增加经验值";
				披风强化每一阶段增加经验值 = double.Parse(Config.IniReadValue("GameServer", "披风强化每一阶段增加经验值").Trim());
				text = "披风强化需要物品ID";
				披风强化需要物品ID = int.Parse(Config.IniReadValue("GameServer", "披风强化需要物品ID").Trim());
				text = "披风强化需要物品ID数量";
				披风强化需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "披风强化需要物品ID数量").Trim());
				text = "披风强化系统提示公告";
				披风强化系统提示公告 = Config.IniReadValue("GameServer", "披风强化系统提示公告").Trim();
				text = "披风强化最高阶段";
				披风强化最高阶段 = int.Parse(Config.IniReadValue("GameServer", "披风强化最高阶段").Trim());
				text = "是否开启披风进阶";
				是否开启披风进阶 = int.Parse(Config.IniReadValue("GameServer", "是否开启披风进阶").Trim());
				text = "进阶披风元宝所需数量";
				进阶披风元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶披风元宝所需数量").Trim());
				text = "进阶披风积分所需数量";
				进阶披风积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶披风积分所需数量").Trim());
				text = "进阶披风武勋所需数量";
				进阶披风武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶披风武勋所需数量").Trim());
				text = "进阶披风金币所需数量";
				进阶披风金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶披风金币所需数量").Trim());
				text = "披风进阶成功率";
				披风进阶成功率 = Config.IniReadValue("GameServer", "披风进阶成功率").Trim();
				text = "武器强化每一阶段增加防御";
				武器强化每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "武器强化每一阶段增加防御").Trim());
				text = "武器强化每一阶段增加攻击";
				武器强化每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "武器强化每一阶段增加攻击").Trim());
				text = "武器强化每一阶段增加生命";
				武器强化每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "武器强化每一阶段增加生命").Trim());
				text = "武器强化每一阶段增加蓝值";
				武器强化每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "武器强化每一阶段增加蓝值").Trim());
				text = "武器强化需要物品ID";
				武器强化需要物品ID = int.Parse(Config.IniReadValue("GameServer", "武器强化需要物品ID").Trim());
				text = "武器强化需要物品ID数量";
				武器强化需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "武器强化需要物品ID数量").Trim());
				text = "武器强化系统提示公告";
				武器强化系统提示公告 = Config.IniReadValue("GameServer", "武器强化系统提示公告").Trim();
				text = "武器强化最高等级";
				武器强化最高等级 = int.Parse(Config.IniReadValue("GameServer", "武器强化最高等级").Trim());
				text = "是否开启武器强化";
				是否开启武器强化 = int.Parse(Config.IniReadValue("GameServer", "是否开启武器强化").Trim());
				text = "强化武器元宝所需数量";
				强化武器元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化武器元宝所需数量").Trim());
				text = "强化武器积分所需数量";
				强化武器积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化武器积分所需数量").Trim());
				text = "强化武器武勋所需数量";
				强化武器武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化武器武勋所需数量").Trim());
				text = "强化武器金币所需数量";
				强化武器金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化武器金币所需数量").Trim());
				text = "武器强化成功率";
				武器强化成功率 = Config.IniReadValue("GameServer", "武器强化成功率").Trim();
				text = "防具强化每一阶段增加防御";
				防具强化每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "防具强化每一阶段增加防御").Trim());
				text = "防具强化每一阶段增加攻击";
				防具强化每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "防具强化每一阶段增加攻击").Trim());
				text = "防具强化每一阶段增加生命";
				防具强化每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "防具强化每一阶段增加生命").Trim());
				text = "防具强化每一阶段增加蓝值";
				防具强化每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "防具强化每一阶段增加蓝值").Trim());
				text = "防具强化需要物品ID";
				防具强化需要物品ID = int.Parse(Config.IniReadValue("GameServer", "防具强化需要物品ID").Trim());
				text = "防具强化需要物品ID数量";
				防具强化需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "防具强化需要物品ID数量").Trim());
				text = "防具强化系统提示公告";
				防具强化系统提示公告 = Config.IniReadValue("GameServer", "防具强化系统提示公告").Trim();
				text = "防具强化最高等级";
				防具强化最高等级 = int.Parse(Config.IniReadValue("GameServer", "防具强化最高等级").Trim());
				text = "是否开启防具强化";
				是否开启防具强化 = int.Parse(Config.IniReadValue("GameServer", "是否开启防具强化").Trim());
				text = "强化防具元宝所需数量";
				强化防具元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化防具元宝所需数量").Trim());
				text = "强化防具积分所需数量";
				强化防具积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化防具积分所需数量").Trim());
				text = "强化防具武勋所需数量";
				强化防具武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化防具武勋所需数量").Trim());
				text = "强化防具金币所需数量";
				强化防具金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "强化防具金币所需数量").Trim());
				text = "防具强化成功率";
				防具强化成功率 = Config.IniReadValue("GameServer", "防具强化成功率").Trim();
				text = "门甲升级需要物品ID";
				门甲升级需要物品ID = int.Parse(Config.IniReadValue("GameServer", "门甲升级需要物品ID").Trim());
				text = "门甲升级需要物品ID数量";
				门甲升级需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "门甲升级需要物品ID数量").Trim());
				text = "是否开启门甲升级";
				是否开启门甲升级 = int.Parse(Config.IniReadValue("GameServer", "是否开启门甲升级").Trim());
				text = "升级门甲所需物品ID";
				是否开启门甲升级 = int.Parse(Config.IniReadValue("GameServer", "升级门甲所需物品ID").Trim());
				text = "门甲升级元宝所需数量";
				门甲升级金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "门甲升级元宝所需数量").Trim());
				text = "门甲升级金币所需数量";
				门甲升级金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "门甲升级金币所需数量").Trim());
				text = "门甲升级成功率";
				门甲升级成功率 = Config.IniReadValue("GameServer", "门甲升级成功率").Trim();
				text = "耳环进阶每一阶段增加防御";
				耳环进阶每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶每一阶段增加防御").Trim());
				text = "耳环进阶每一阶段增加攻击";
				耳环进阶每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶每一阶段增加攻击").Trim());
				text = "耳环进阶每一阶段增加生命";
				耳环进阶每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶每一阶段增加生命").Trim());
				text = "耳环进阶每一阶段增加蓝值";
				耳环进阶每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶每一阶段增加蓝值").Trim());
				text = "耳环进阶需要物品ID";
				耳环进阶需要物品ID = int.Parse(Config.IniReadValue("GameServer", "耳环进阶需要物品ID").Trim());
				text = "耳环进阶需要物品ID数量";
				耳环进阶需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶需要物品ID数量").Trim());
				text = "耳环进阶系统提示公告";
				耳环进阶系统提示公告 = Config.IniReadValue("GameServer", "耳环进阶系统提示公告").Trim();
				text = "耳环进阶最高阶段";
				耳环进阶最高阶段 = int.Parse(Config.IniReadValue("GameServer", "耳环进阶最高阶段").Trim());
				text = "是否开启耳环进阶";
				是否开启耳环进阶 = int.Parse(Config.IniReadValue("GameServer", "是否开启耳环进阶").Trim());
				text = "进阶耳环元宝所需数量";
				进阶耳环元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶耳环元宝所需数量").Trim());
				text = "进阶耳环积分所需数量";
				进阶耳环积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶耳环积分所需数量").Trim());
				text = "进阶耳环武勋所需数量";
				进阶耳环武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶耳环武勋所需数量").Trim());
				text = "进阶耳环金币所需数量";
				进阶耳环金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶耳环金币所需数量").Trim());
				text = "耳环进阶成功率";
				耳环进阶成功率 = Config.IniReadValue("GameServer", "耳环进阶成功率").Trim();
				text = "戒指进阶每一阶段增加防御";
				戒指进阶每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶每一阶段增加防御").Trim());
				text = "戒指进阶每一阶段增加攻击";
				戒指进阶每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶每一阶段增加攻击").Trim());
				text = "戒指进阶每一阶段增加生命";
				戒指进阶每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶每一阶段增加生命").Trim());
				text = "戒指进阶每一阶段增加蓝值";
				戒指进阶每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶每一阶段增加蓝值").Trim());
				text = "戒指进阶需要物品ID";
				戒指进阶需要物品ID = int.Parse(Config.IniReadValue("GameServer", "戒指进阶需要物品ID").Trim());
				text = "戒指进阶需要物品ID数量";
				戒指进阶需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶需要物品ID数量").Trim());
				text = "戒指进阶系统提示公告";
				戒指进阶系统提示公告 = Config.IniReadValue("GameServer", "戒指进阶系统提示公告").Trim();
				text = "戒指进阶最高阶段";
				戒指进阶最高阶段 = int.Parse(Config.IniReadValue("GameServer", "戒指进阶最高阶段").Trim());
				text = "是否开启戒指进阶";
				是否开启戒指进阶 = int.Parse(Config.IniReadValue("GameServer", "是否开启戒指进阶").Trim());
				text = "进阶戒指元宝所需数量";
				进阶戒指元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶戒指元宝所需数量").Trim());
				text = "进阶戒指积分所需数量";
				进阶戒指积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶戒指积分所需数量").Trim());
				text = "进阶戒指武勋所需数量";
				进阶戒指武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶戒指武勋所需数量").Trim());
				text = "进阶戒指金币所需数量";
				进阶戒指金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶戒指金币所需数量").Trim());
				text = "戒指进阶成功率";
				戒指进阶成功率 = Config.IniReadValue("GameServer", "戒指进阶成功率").Trim();
				text = "项链进阶每一阶段增加防御";
				项链进阶每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "项链进阶每一阶段增加防御").Trim());
				text = "项链进阶每一阶段增加攻击";
				项链进阶每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "项链进阶每一阶段增加攻击").Trim());
				text = "项链进阶每一阶段增加生命";
				项链进阶每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "项链进阶每一阶段增加生命").Trim());
				text = "项链进阶每一阶段增加蓝值";
				项链进阶每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "项链进阶每一阶段增加蓝值").Trim());
				text = "项链进阶需要物品ID";
				项链进阶需要物品ID = int.Parse(Config.IniReadValue("GameServer", "项链进阶需要物品ID").Trim());
				text = "项链进阶需要物品ID数量";
				项链进阶需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "项链进阶需要物品ID数量").Trim());
				text = "项链进阶系统提示公告";
				项链进阶系统提示公告 = Config.IniReadValue("GameServer", "项链进阶系统提示公告").Trim();
				text = "项链进阶最高阶段";
				项链进阶最高阶段 = int.Parse(Config.IniReadValue("GameServer", "项链进阶最高阶段").Trim());
				text = "是否开启项链进阶";
				是否开启项链进阶 = int.Parse(Config.IniReadValue("GameServer", "是否开启项链进阶").Trim());
				text = "进阶项链元宝所需数量";
				进阶项链元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶项链元宝所需数量").Trim());
				text = "进阶项链积分所需数量";
				进阶项链积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶项链积分所需数量").Trim());
				text = "进阶项链武勋所需数量";
				进阶项链武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶项链武勋所需数量").Trim());
				text = "进阶项链金币所需数量";
				进阶项链金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶项链金币所需数量").Trim());
				text = "项链进阶成功率";
				项链进阶成功率 = Config.IniReadValue("GameServer", "项链进阶成功率").Trim();
				text = "宠物进阶每一阶段增加防御";
				宠物进阶每一阶段增加防御 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶每一阶段增加防御").Trim());
				text = "宠物进阶每一阶段增加攻击";
				宠物进阶每一阶段增加攻击 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶每一阶段增加攻击").Trim());
				text = "宠物进阶每一阶段增加生命";
				宠物进阶每一阶段增加生命 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶每一阶段增加生命").Trim());
				text = "宠物进阶每一阶段增加蓝值";
				宠物进阶每一阶段增加蓝值 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶每一阶段增加蓝值").Trim());
				text = "宠物进阶需要物品ID";
				宠物进阶需要物品ID = int.Parse(Config.IniReadValue("GameServer", "宠物进阶需要物品ID").Trim());
				text = "宠物进阶需要物品ID数量";
				宠物进阶需要物品ID数量 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶需要物品ID数量").Trim());
				text = "宠物进阶系统提示公告";
				宠物进阶系统提示公告 = Config.IniReadValue("GameServer", "宠物进阶系统提示公告").Trim();
				text = "宠物进阶高阶段";
				宠物进阶高阶段 = int.Parse(Config.IniReadValue("GameServer", "宠物进阶高阶段").Trim());
				text = "是否开启宠物进阶";
				是否开启宠物进阶 = int.Parse(Config.IniReadValue("GameServer", "是否开启宠物进阶").Trim());
				text = "进阶宠物元宝所需数量";
				进阶宠物元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶宠物元宝所需数量").Trim());
				text = "进阶宠物积分所需数量";
				进阶宠物积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶宠物积分所需数量").Trim());
				text = "进阶宠物武勋所需数量";
				进阶宠物武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶宠物武勋所需数量").Trim());
				text = "进阶宠物金币所需数量";
				进阶宠物金币所需数量 = int.Parse(Config.IniReadValue("GameServer", "进阶宠物金币所需数量").Trim());
				text = "宠物进阶成功率";
				宠物进阶成功率 = Config.IniReadValue("GameServer", "宠物进阶成功率").Trim();
				text = "幸运奖是否开启";
				幸运奖是否开启 = int.Parse(Config.IniReadValue("GameServer", "幸运奖是否开启").Trim());
				text = "幸运奖开启小时";
				幸运奖开启小时 = int.Parse(Config.IniReadValue("GameServer", "幸运奖开启小时").Trim());
				text = "幸运奖开启分";
				幸运奖开启分 = int.Parse(Config.IniReadValue("GameServer", "幸运奖开启分").Trim());
				text = "幸运奖开启秒";
				幸运奖开启秒 = int.Parse(Config.IniReadValue("GameServer", "幸运奖开启秒").Trim());
				text = "幸运奖配置";
				幸运奖配置 = Config.IniReadValue("GameServer", "幸运奖配置").Trim();
				text = "幸运奖奖励";
				幸运奖奖励 = Config.IniReadValue("GameServer", "幸运奖奖励").Trim();
				text = "幸运奖倒计时间1";
				幸运奖倒计时间1 = ((Config.IniReadValue("GameServer", "幸运奖倒计时间1") == "") ? 幸运奖倒计时间1 : double.Parse(Config.IniReadValue("GameServer", "幸运奖倒计时间1")));
				text = "幸运奖倒计时间2";
				幸运奖倒计时间2 = ((Config.IniReadValue("GameServer", "幸运奖倒计时间2") == "") ? 幸运奖倒计时间2 : double.Parse(Config.IniReadValue("GameServer", "幸运奖倒计时间2")));
				text = "购买彩票下注类型";
				购买彩票下注类型 = int.Parse(Config.IniReadValue("GameServer", "购买彩票下注类型").Trim());
				text = "购买彩票命令";
				购买彩票命令 = Config.IniReadValue("GameServer", "购买彩票命令").Trim();
				text = "彩票开奖内容";
				彩票开奖内容 = Config.IniReadValue("GameServer", "彩票开奖内容").Trim();
				text = "彩票是否开启";
				彩票是否开启 = int.Parse(Config.IniReadValue("GameServer", "彩票是否开启").Trim());
				text = "彩票开启小时";
				彩票开启小时 = int.Parse(Config.IniReadValue("GameServer", "彩票开启小时").Trim());
				text = "彩票开启分";
				彩票开启分 = int.Parse(Config.IniReadValue("GameServer", "彩票开启分").Trim());
				text = "彩票开启秒";
				彩票开启秒 = int.Parse(Config.IniReadValue("GameServer", "彩票开启秒").Trim());
				text = "彩票下注最小数";
				彩票下注最小数 = int.Parse(Config.IniReadValue("GameServer", "彩票下注最小数").Trim());
				text = "彩票下注最大数";
				彩票下注最大数 = int.Parse(Config.IniReadValue("GameServer", "彩票下注最大数").Trim());
				text = "彩票中一个倍数";
				彩票中一个倍数 = int.Parse(Config.IniReadValue("GameServer", "彩票中一个倍数").Trim());
				text = "彩票中两个倍数";
				彩票中两个倍数 = int.Parse(Config.IniReadValue("GameServer", "彩票中两个倍数").Trim());
				text = "彩票全中倍数";
				彩票全中倍数 = int.Parse(Config.IniReadValue("GameServer", "彩票全中倍数").Trim());
				text = "彩票中特别倍数";
				彩票中特别倍数 = int.Parse(Config.IniReadValue("GameServer", "彩票中特别倍数").Trim());
				text = "时时彩命令";
				时时彩命令 = Config.IniReadValue("GameServer", "时时彩命令").Trim();
				text = "是否开启随机号码";
				是否开启随机号码 = int.Parse(Config.IniReadValue("GameServer", "是否开启随机号码").Trim());
				text = "时时彩开启号码";
				时时彩开启号码 = Config.IniReadValue("GameServer", "时时彩开启号码").Trim();
				text = "时时彩倒计时";
				时时彩倒计时 = int.Parse(Config.IniReadValue("GameServer", "时时彩倒计时").Trim());
				text = "时时彩是否开启";
				时时彩是否开启 = int.Parse(Config.IniReadValue("GameServer", "时时彩是否开启").Trim());
				text = "时时彩下注类型";
				时时彩下注类型 = int.Parse(Config.IniReadValue("GameServer", "时时彩下注类型").Trim());
				text = "时时彩全中倍数";
				时时彩全中倍数 = int.Parse(Config.IniReadValue("GameServer", "时时彩全中倍数").Trim());
				text = "时时彩中两个倍数";
				时时彩中两个倍数 = int.Parse(Config.IniReadValue("GameServer", "时时彩中两个倍数").Trim());
				text = "时时彩中一个倍数";
				时时彩中一个倍数 = int.Parse(Config.IniReadValue("GameServer", "时时彩中一个倍数").Trim());
				text = "时时彩下注最小数";
				时时彩下注最小数 = int.Parse(Config.IniReadValue("GameServer", "时时彩下注最小数").Trim());
				text = "时时彩下注最大数";
				时时彩下注最大数 = int.Parse(Config.IniReadValue("GameServer", "时时彩下注最大数").Trim());
				text = "时时彩开奖内容";
				时时彩开奖内容 = Config.IniReadValue("GameServer", "时时彩开奖内容").Trim();
				text = "打劫命令";
				打劫命令 = Config.IniReadValue("GameServer", "打劫命令").Trim();
				text = "是否开启打劫系统";
				是否开启打劫系统 = int.Parse(Config.IniReadValue("GameServer", "是否开启打劫系统").Trim());
				text = "打劫成功获得元宝";
				打劫成功获得元宝 = int.Parse(Config.IniReadValue("GameServer", "打劫成功获得元宝").Trim());
				text = "打劫成功获得积分";
				打劫成功获得积分 = int.Parse(Config.IniReadValue("GameServer", "打劫成功获得积分").Trim());
				text = "打劫成功获得武勋";
				打劫成功获得武勋 = int.Parse(Config.IniReadValue("GameServer", "打劫成功获得武勋").Trim());
				text = "打劫失败扣除元宝";
				打劫失败扣除元宝 = int.Parse(Config.IniReadValue("GameServer", "打劫失败扣除元宝").Trim());
				text = "打劫失败扣除积分";
				打劫失败扣除积分 = int.Parse(Config.IniReadValue("GameServer", "打劫失败扣除积分").Trim());
				text = "打劫失败扣除武勋";
				打劫失败扣除武勋 = int.Parse(Config.IniReadValue("GameServer", "打劫失败扣除武勋").Trim());
				text = "打劫元宝所需数量";
				打劫元宝所需数量 = int.Parse(Config.IniReadValue("GameServer", "打劫元宝所需数量").Trim());
				text = "打劫积分所需数量";
				打劫积分所需数量 = int.Parse(Config.IniReadValue("GameServer", "打劫积分所需数量").Trim());
				text = "打劫武勋所需数量";
				打劫武勋所需数量 = int.Parse(Config.IniReadValue("GameServer", "打劫武勋所需数量").Trim());
				text = "是否开启打劫类型";
				是否开启打劫类型 = int.Parse(Config.IniReadValue("GameServer", "是否开启打劫类型").Trim());
				text = "打劫成功机率";
				打劫成功机率 = int.Parse(Config.IniReadValue("GameServer", "打劫成功机率").Trim());
				text = "打劫间隔时间";
				打劫间隔时间 = int.Parse(Config.IniReadValue("GameServer", "打劫间隔时间").Trim());
				text = "骰子配置";
				骰子配置 = Config.IniReadValue("GameServer", "骰子配置").Trim();
				text = "骰子豹子奖励倍数";
				骰子豹子奖励倍数 = ((Config.IniReadValue("GameServer", "骰子豹子奖励倍数") == "") ? 骰子豹子奖励倍数 : double.Parse(Config.IniReadValue("GameServer", "骰子豹子奖励倍数")));
				text = "骰子大小奖励倍数";
				骰子大小奖励倍数 = ((Config.IniReadValue("GameServer", "骰子大小奖励倍数") == "") ? 骰子大小奖励倍数 : double.Parse(Config.IniReadValue("GameServer", "骰子大小奖励倍数")));
				text = "骰子点数奖励倍数";
				骰子点数奖励倍数 = ((Config.IniReadValue("GameServer", "骰子点数奖励倍数") == "") ? 骰子点数奖励倍数 : double.Parse(Config.IniReadValue("GameServer", "骰子点数奖励倍数")));
				text = "骰子最大下注额";
				骰子最大下注额 = int.Parse(Config.IniReadValue("GameServer", "骰子最大下注额").Trim());
				text = "骰子最小下注额";
				骰子最小下注额 = int.Parse(Config.IniReadValue("GameServer", "骰子最小下注额").Trim());
				text = "骰子开奖倒计时间1";
				骰子开奖倒计时间1 = ((Config.IniReadValue("GameServer", "骰子开奖倒计时间1") == "") ? 骰子开奖倒计时间1 : double.Parse(Config.IniReadValue("GameServer", "骰子开奖倒计时间1")));
				text = "骰子开奖倒计时间2";
				骰子开奖倒计时间2 = ((Config.IniReadValue("GameServer", "骰子开奖倒计时间2") == "") ? 骰子开奖倒计时间2 : double.Parse(Config.IniReadValue("GameServer", "骰子开奖倒计时间2")));
				text = "骰子提示设置";
				骰子提示设置 = Config.IniReadValue("GameServer", "骰子提示设置").Trim();
				text = "骰子控制开始时间";
				骰子控制开始时间 = int.Parse(Config.IniReadValue("GameServer", "骰子控制开始时间").Trim());
				text = "骰子控制结束时间";
				骰子控制结束时间 = int.Parse(Config.IniReadValue("GameServer", "骰子控制结束时间").Trim());
				text = "骰子功能是否开启";
				骰子功能是否开启 = int.Parse(Config.IniReadValue("GameServer", "骰子功能是否开启").Trim());
				text = "是否开启赌博类型";
				是否开启赌博类型 = int.Parse(Config.IniReadValue("GameServer", "是否开启赌博类型").Trim());
				text = "作假下注额";
				作假下注额 = int.Parse(Config.IniReadValue("GameServer", "作假下注额").Trim());
				text = "是否开启重复下注处罚";
				是否开启重复下注处罚 = int.Parse(Config.IniReadValue("GameServer", "是否开启重复下注处罚").Trim());
				text = "骰子公告间隔时间";
				骰子公告间隔时间 = ((Config.IniReadValue("GameServer", "骰子公告间隔时间").Trim() == "") ? 骰子公告间隔时间 : double.Parse(Config.IniReadValue("GameServer", "骰子公告间隔时间").Trim()));
				text = "骰子开启公告内容";
				骰子开启公告内容 = ((Config.IniReadValue("GameServer", "骰子开启公告内容").Trim() == "") ? 骰子开启公告内容 : Config.IniReadValue("GameServer", "骰子开启公告内容").Trim());
				text = "骰子参与元宝公告内容";
				骰子参与元宝公告内容 = ((Config.IniReadValue("GameServer", "骰子参与元宝公告内容").Trim() == "") ? 骰子开启公告内容 : Config.IniReadValue("GameServer", "骰子参与元宝公告内容").Trim());
				text = "骰子参与积分公告内容";
				骰子参与积分公告内容 = ((Config.IniReadValue("GameServer", "骰子参与积分公告内容").Trim() == "") ? 骰子开启公告内容 : Config.IniReadValue("GameServer", "骰子参与积分公告内容").Trim());
				text = "骰子参与武勋公告内容";
				骰子参与武勋公告内容 = ((Config.IniReadValue("GameServer", "骰子参与武勋公告内容").Trim() == "") ? 骰子开启公告内容 : Config.IniReadValue("GameServer", "骰子参与武勋公告内容").Trim());
				text = "科举配置";
				科举配置 = Config.IniReadValue("GameServer", "科举配置").Trim();
				text = "科举是否开启";
				科举是否开启 = int.Parse(Config.IniReadValue("GameServer", "科举是否开启").Trim());
				text = "科举开启时";
				科举开启时 = int.Parse(Config.IniReadValue("GameServer", "科举开启时").Trim());
				text = "科举开启分";
				科举开启分 = int.Parse(Config.IniReadValue("GameServer", "科举开启分").Trim());
				text = "科举开启秒";
				科举开启秒 = int.Parse(Config.IniReadValue("GameServer", "科举开启秒").Trim());
				text = "科举提示设置";
				科举提示设置 = Config.IniReadValue("GameServer", "科举提示设置").Trim();
				text = "科举倒计时间1";
				科举倒计时间1 = ((Config.IniReadValue("GameServer", "科举倒计时间1") == "") ? 科举倒计时间1 : double.Parse(Config.IniReadValue("GameServer", "科举倒计时间1")));
				text = "科举倒计时间2";
				科举倒计时间2 = ((Config.IniReadValue("GameServer", "科举倒计时间2") == "") ? 科举倒计时间2 : double.Parse(Config.IniReadValue("GameServer", "科举倒计时间2")));
				text = "科举公告间隔时间";
				科举公告间隔时间 = ((Config.IniReadValue("GameServer", "科举公告间隔时间").Trim() == "") ? 科举公告间隔时间 : double.Parse(Config.IniReadValue("GameServer", "科举公告间隔时间").Trim()));
				text = "科举答题间隔时间";
				科举答题间隔时间 = int.Parse(Config.IniReadValue("GameServer", "科举答题间隔时间").Trim());
				text = "科举答题回答时间";
				科举答题回答时间 = int.Parse(Config.IniReadValue("GameServer", "科举答题回答时间").Trim());
				text = "科举奖励类型";
				科举奖励类型 = int.Parse(Config.IniReadValue("GameServer", "科举奖励类型").Trim());
				text = "科举考试奖励类型";
				科举考试奖励类型 = int.Parse(Config.IniReadValue("GameServer", "科举考试奖励类型").Trim());
				text = "科举奖励第一名奖元宝";
				科举奖励第一名奖元宝 = int.Parse(Config.IniReadValue("GameServer", "科举奖励第一名奖元宝").Trim());
				text = "科举奖励第一名奖积分";
				科举奖励第一名奖积分 = int.Parse(Config.IniReadValue("GameServer", "科举奖励第一名奖积分").Trim());
				text = "科举奖励第一名奖武勋";
				科举奖励第一名奖武勋 = int.Parse(Config.IniReadValue("GameServer", "科举奖励第一名奖武勋").Trim());
				text = "改变职业元宝数";
				改变职业元宝数 = int.Parse(Config.IniReadValue("GameServer", "改变职业元宝数").Trim());
				text = "改变职业积分数";
				改变职业积分数 = int.Parse(Config.IniReadValue("GameServer", "改变职业积分数").Trim());
				text = "改变职业武勋数";
				改变职业武勋数 = int.Parse(Config.IniReadValue("GameServer", "改变职业武勋数").Trim());
				text = "改变职业金币数";
				改变职业金币数 = int.Parse(Config.IniReadValue("GameServer", "改变职业金币数").Trim());
				text = "改变职业所需转职等级";
				改变职业所需转职等级 = int.Parse(Config.IniReadValue("GameServer", "改变职业所需转职等级").Trim());
				text = "是否开启改变职业";
				是否开启改变职业 = int.Parse(Config.IniReadValue("GameServer", "是否开启改变职业").Trim());
				text = "转换正邪是否开启";
				转换正邪是否开启 = int.Parse(Config.IniReadValue("GameServer", "转换正邪是否开启").Trim());
				text = "转换正邪需要元宝";
				转换正邪需要元宝 = int.Parse(Config.IniReadValue("GameServer", "转换正邪需要元宝").Trim());
				text = "转换正邪需要积分";
				转换正邪需要积分 = int.Parse(Config.IniReadValue("GameServer", "转换正邪需要积分").Trim());
				text = "转换正邪需要武勋";
				转换正邪需要武勋 = int.Parse(Config.IniReadValue("GameServer", "转换正邪需要武勋").Trim());
				text = "转换正邪需要金币";
				转换正邪需要金币 = int.Parse(Config.IniReadValue("GameServer", "转换正邪需要金币").Trim());
				text = "转换正邪所需转职等级";
				转换正邪所需转职等级 = int.Parse(Config.IniReadValue("GameServer", "转换正邪所需转职等级").Trim());
				text = "武勋防具封顶属性";
				武勋防具封顶属性 = int.Parse(Config.IniReadValue("GameServer", "武勋防具封顶属性").Trim());
				text = "四武器封顶属性";
				四武器封顶属性 = int.Parse(Config.IniReadValue("GameServer", "四武器封顶属性").Trim());
				text = "七武器封顶属性";
				七武器封顶属性 = int.Parse(Config.IniReadValue("GameServer", "七武器封顶属性").Trim());
				text = "十武器封顶属性";
				十武器封顶属性 = int.Parse(Config.IniReadValue("GameServer", "十武器封顶属性").Trim());
				text = "十三武器封顶属性";
				十三武器封顶属性 = int.Parse(Config.IniReadValue("GameServer", "十三武器封顶属性").Trim());
				text = "万能卡重造属性需要元宝数";
				万能卡重造属性需要元宝数 = int.Parse(Config.IniReadValue("GameServer", "万能卡重造属性需要元宝数").Trim());
				text = "万能卡重造属性需要积分数";
				万能卡重造属性需要积分数 = int.Parse(Config.IniReadValue("GameServer", "万能卡重造属性需要积分数").Trim());
				text = "万能卡重造属性需要武勋数";
				万能卡重造属性需要武勋数 = int.Parse(Config.IniReadValue("GameServer", "万能卡重造属性需要武勋数").Trim());
				text = "万能卡重造属性需要金币数";
				万能卡重造属性需要金币数 = int.Parse(Config.IniReadValue("GameServer", "万能卡重造属性需要金币数").Trim());
				text = "进阶成功率";
				进阶成功率 = Config.IniReadValue("GameServer", "进阶成功率").Trim();
				text = "装备使用万能卡后是否绑定";
				装备使用万能卡后是否绑定 = int.Parse(Config.IniReadValue("GameServer", "装备使用万能卡后是否绑定").Trim());
				text = "回收几的武器";
				回收几的武器 = Config.IniReadValue("GameServer", "回收几的武器").Trim();
				text = "武勋阶段一需要";
				武勋阶段一需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段一需要").Trim());
				text = "武勋阶段二需要";
				武勋阶段二需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段二需要").Trim());
				text = "武勋阶段三需要";
				武勋阶段三需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段三需要").Trim());
				text = "武勋阶段四需要";
				武勋阶段四需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段四需要").Trim());
				text = "武勋阶段五需要";
				武勋阶段五需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段五需要").Trim());
				text = "武勋阶段六需要";
				武勋阶段六需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段六需要").Trim());
				text = "武勋阶段七需要";
				武勋阶段七需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段七需要").Trim());
				text = "武勋阶段八需要";
				武勋阶段八需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段八需要").Trim());
				text = "武勋阶段九需要";
				武勋阶段九需要 = double.Parse(Config.IniReadValue("GameServer", "武勋阶段九需要").Trim());
				text = "武勋值扩展属性开关";
				武勋值扩展属性开关 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性开关").Trim());
				text = "武勋值扩展属性数值";
				武勋值扩展属性数值 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性数值").Trim());
				text = "武勋值扩展属性攻击增加";
				武勋值扩展属性攻击增加 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性攻击增加").Trim());
				text = "武勋值扩展属性防御增加";
				武勋值扩展属性防御增加 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性防御增加").Trim());
				text = "武勋值扩展属性生命增加";
				武勋值扩展属性生命增加 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性生命增加").Trim());
				text = "武勋值扩展属性蓝值增加";
				武勋值扩展属性蓝值增加 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性蓝值增加").Trim());
				text = "武勋值扩展属性气功增加";
				武勋值扩展属性气功增加 = int.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性气功增加").Trim());
				text = "武勋值扩展属性经验百分比";
				武勋值扩展属性经验百分比 = double.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性经验百分比").Trim());
				text = "武勋值扩展属性金钱百分比";
				武勋值扩展属性金钱百分比 = double.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性金钱百分比").Trim());
				text = "武勋值扩展属性历练百分比";
				武勋值扩展属性历练百分比 = double.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性历练百分比").Trim());
				text = "武勋值扩展属性爆率百分比";
				武勋值扩展属性爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "武勋值扩展属性爆率百分比").Trim());
				text = "武勋阶段1";
				武勋阶段1 = Config.IniReadValue("GameServer", "武勋阶段1").Trim().Split(';');
				text = "武勋阶段2";
				武勋阶段2 = Config.IniReadValue("GameServer", "武勋阶段2").Trim().Split(';');
				text = "武勋阶段3";
				武勋阶段3 = Config.IniReadValue("GameServer", "武勋阶段3").Trim().Split(';');
				text = "武勋阶段4";
				武勋阶段4 = Config.IniReadValue("GameServer", "武勋阶段4").Trim().Split(';');
				text = "武勋阶段5";
				武勋阶段5 = Config.IniReadValue("GameServer", "武勋阶段5").Trim().Split(';');
				text = "武勋阶段6";
				武勋阶段6 = Config.IniReadValue("GameServer", "武勋阶段6").Trim().Split(';');
				text = "武勋阶段7";
				武勋阶段7 = Config.IniReadValue("GameServer", "武勋阶段7").Trim().Split(';');
				text = "武勋阶段8";
				武勋阶段8 = Config.IniReadValue("GameServer", "武勋阶段8").Trim().Split(';');
				text = "武勋阶段9";
				武勋阶段9 = Config.IniReadValue("GameServer", "武勋阶段9").Trim().Split(';');
				text = "监控开店购买记录";
				监控开店购买记录 = int.Parse(Config.IniReadValue("GameServer", "监控开店购买记录").Trim());
				text = "是否开启综合商店";
				是否开启综合商店 = int.Parse(Config.IniReadValue("GameServer", "是否开启综合商店").Trim());
				text = "BOSS不受越级检测开关";
				BOSS不受越级检测开关 = int.Parse(Config.IniReadValue("GameServer", "BOSS不受越级检测开关").Trim());
				text = "BOSS怪随机掉落物品数量";
				BOSS怪随机掉落物品数量 = Config.IniReadValue("GameServer", "BOSS怪随机掉落物品数量").Trim();
				text = "百宝送积分是否开启";
				百宝送积分是否开启 = ((Config.IniReadValue("GameServer", "百宝送积分是否开启").Trim() == "") ? 百宝送积分是否开启 : int.Parse(Config.IniReadValue("GameServer", "百宝送积分是否开启").Trim()));
				text = "是否开启高倍经验开关";
				是否开启高倍经验开关 = int.Parse(Config.IniReadValue("GameServer", "是否开启高倍经验开关").Trim());
				text = "获得物品等级差上线";
				获得物品等级差上线 = int.Parse(Config.IniReadValue("GameServer", "获得物品等级差上线").Trim());
				text = "获得物品等级差下线";
				获得物品等级差下线 = int.Parse(Config.IniReadValue("GameServer", "获得物品等级差下线").Trim());
				text = "怪物防御百分比";
				怪物防御百分比 = ((Config.IniReadValue("GameServer", "怪物防御百分比") == "") ? 怪物防御百分比 : double.Parse(Config.IniReadValue("GameServer", "怪物防御百分比")));
				text = "怪物攻击下降倍数";
				怪物攻击下降倍数 = double.Parse(Config.IniReadValue("GameServer", "怪物攻击下降倍数").Trim());
				text = "怪物暴击伤害百分比";
				怪物暴击伤害百分比 = double.Parse(Config.IniReadValue("GameServer", "怪物暴击伤害百分比").Trim());
				text = "金符出售物品百分比";
				金符出售物品百分比 = ((Config.IniReadValue("GameServer", "金符出售物品百分比").Trim() == "") ? 金符出售物品百分比 : double.Parse(Config.IniReadValue("GameServer", "金符出售物品百分比").Trim()));
				text = "出售物品百分比";
				出售物品百分比 = ((Config.IniReadValue("GameServer", "出售物品百分比").Trim() == "") ? 出售物品百分比 : double.Parse(Config.IniReadValue("GameServer", "出售物品百分比").Trim()));
				text = "怪物死亡触发器";
				怪物死亡触发器 = ((Config.IniReadValue("GameServer", "怪物死亡触发器").Trim() == "") ? 怪物死亡触发器 : int.Parse(Config.IniReadValue("GameServer", "怪物死亡触发器").Trim()));
				text = "会员最高等级";
				会员最高等级 = ((Config.IniReadValue("GameServer", "会员最高等级").Trim() == "") ? 0 : long.Parse(Config.IniReadValue("GameServer", "会员最高等级").Trim()));
				text = "升级会员需要属性";
				升级会员需要属性 = Config.IniReadValue("GameServer", "升级会员需要属性").Trim();
				text = "物品兑换LUA脚本是否开启";
				物品兑换LUA脚本是否开启 = int.Parse(Config.IniReadValue("GameServer", "物品兑换LUA脚本是否开启").Trim());
				text = "门派升级命令";
				门派升级命令 = Config.IniReadValue("GameServer", "门派升级命令").Trim();
				text = "二级门派升级所需金钱";
				二级门派升级所需金钱 = int.Parse(Config.IniReadValue("GameServer", "二级门派升级所需金钱").Trim());
				text = "二级门派升级所需元宝";
				二级门派升级所需元宝 = int.Parse(Config.IniReadValue("GameServer", "二级门派升级所需元宝").Trim());
				text = "二级门派升级所需积分";
				二级门派升级所需积分 = int.Parse(Config.IniReadValue("GameServer", "二级门派升级所需积分").Trim());
				text = "二级门派升级所需武勋";
				二级门派升级所需武勋 = int.Parse(Config.IniReadValue("GameServer", "二级门派升级所需武勋").Trim());
				text = "二级门派升级所需声望";
				二级门派升级所需声望 = int.Parse(Config.IniReadValue("GameServer", "二级门派升级所需声望").Trim());
				text = "三级门派升级所需金钱";
				三级门派升级所需金钱 = int.Parse(Config.IniReadValue("GameServer", "三级门派升级所需金钱").Trim());
				text = "三级门派升级所需元宝";
				三级门派升级所需元宝 = int.Parse(Config.IniReadValue("GameServer", "三级门派升级所需元宝").Trim());
				text = "三级门派升级所需积分";
				三级门派升级所需积分 = int.Parse(Config.IniReadValue("GameServer", "三级门派升级所需积分").Trim());
				text = "三级门派升级所需武勋";
				三级门派升级所需武勋 = int.Parse(Config.IniReadValue("GameServer", "三级门派升级所需武勋").Trim());
				text = "三级门派升级所需声望";
				三级门派升级所需声望 = int.Parse(Config.IniReadValue("GameServer", "三级门派升级所需声望").Trim());
				text = "四级门派升级所需金钱";
				四级门派升级所需金钱 = int.Parse(Config.IniReadValue("GameServer", "四级门派升级所需金钱").Trim());
				text = "四级门派升级所需元宝";
				四级门派升级所需元宝 = int.Parse(Config.IniReadValue("GameServer", "四级门派升级所需元宝").Trim());
				text = "四级门派升级所需积分";
				四级门派升级所需积分 = int.Parse(Config.IniReadValue("GameServer", "四级门派升级所需积分").Trim());
				text = "四级门派升级所需武勋";
				四级门派升级所需武勋 = int.Parse(Config.IniReadValue("GameServer", "四级门派升级所需武勋").Trim());
				text = "四级门派升级所需声望";
				四级门派升级所需声望 = int.Parse(Config.IniReadValue("GameServer", "四级门派升级所需声望").Trim());
				text = "五级门派升级所需金钱";
				五级门派升级所需金钱 = int.Parse(Config.IniReadValue("GameServer", "五级门派升级所需金钱").Trim());
				text = "五级门派升级所需元宝";
				五级门派升级所需元宝 = int.Parse(Config.IniReadValue("GameServer", "五级门派升级所需元宝").Trim());
				text = "五级门派升级所需积分";
				五级门派升级所需积分 = int.Parse(Config.IniReadValue("GameServer", "五级门派升级所需积分").Trim());
				text = "五级门派升级所需武勋";
				五级门派升级所需武勋 = int.Parse(Config.IniReadValue("GameServer", "五级门派升级所需武勋").Trim());
				text = "五级门派升级所需声望";
				五级门派升级所需声望 = int.Parse(Config.IniReadValue("GameServer", "五级门派升级所需声望").Trim());
				text = "六级门派升级所需金钱";
				六级门派升级所需金钱 = int.Parse(Config.IniReadValue("GameServer", "六级门派升级所需金钱").Trim());
				text = "六级门派升级所需元宝";
				六级门派升级所需元宝 = int.Parse(Config.IniReadValue("GameServer", "六级门派升级所需元宝").Trim());
				text = "六级门派升级所需积分";
				六级门派升级所需积分 = int.Parse(Config.IniReadValue("GameServer", "六级门派升级所需积分").Trim());
				text = "六级门派升级所需武勋";
				六级门派升级所需武勋 = int.Parse(Config.IniReadValue("GameServer", "六级门派升级所需武勋").Trim());
				text = "六级门派升级所需声望";
				六级门派升级所需声望 = int.Parse(Config.IniReadValue("GameServer", "六级门派升级所需声望").Trim());
				text = "二级门派增加经验";
				二级门派增加经验 = double.Parse(Config.IniReadValue("GameServer", "二级门派增加经验").Trim());
				text = "二级门派增加爆率";
				二级门派增加爆率 = double.Parse(Config.IniReadValue("GameServer", "二级门派增加爆率").Trim());
				text = "三级门派增加经验";
				三级门派增加经验 = double.Parse(Config.IniReadValue("GameServer", "三级门派增加经验").Trim());
				text = "三级门派增加爆率";
				三级门派增加爆率 = double.Parse(Config.IniReadValue("GameServer", "三级门派增加爆率").Trim());
				text = "四级门派增加经验";
				四级门派增加经验 = double.Parse(Config.IniReadValue("GameServer", "四级门派增加经验").Trim());
				text = "四级门派增加爆率";
				四级门派增加爆率 = double.Parse(Config.IniReadValue("GameServer", "四级门派增加爆率").Trim());
				text = "五级门派增加经验";
				五级门派增加经验 = double.Parse(Config.IniReadValue("GameServer", "五级门派增加经验").Trim());
				text = "五级门派增加爆率";
				五级门派增加爆率 = double.Parse(Config.IniReadValue("GameServer", "五级门派增加爆率").Trim());
				text = "六级门派增加经验";
				六级门派增加经验 = double.Parse(Config.IniReadValue("GameServer", "六级门派增加经验").Trim());
				text = "六级门派增加爆率";
				六级门派增加爆率 = double.Parse(Config.IniReadValue("GameServer", "六级门派增加爆率").Trim());
				text = "兑换武勋是否开启";
				兑换武勋是否开启 = int.Parse(Config.IniReadValue("GameServer", "兑换武勋是否开启").Trim());
				text = "兑换武勋需要数量";
				兑换武勋需要数量 = int.Parse(Config.IniReadValue("GameServer", "兑换武勋需要数量").Trim());
				text = "需要本身武勋数";
				需要本身武勋数 = int.Parse(Config.IniReadValue("GameServer", "需要本身武勋数").Trim());
				text = "组队经验加成";
				组队经验加成 = Config.IniReadValue("GameServer", "组队经验加成").Trim();
				text = "刀客数量";
				刀客数量 = int.Parse(Config.IniReadValue("GameServer", "刀客数量").Trim());
				text = "剑客数量";
				剑客数量 = int.Parse(Config.IniReadValue("GameServer", "剑客数量").Trim());
				text = "枪客数量";
				枪客数量 = int.Parse(Config.IniReadValue("GameServer", "枪客数量").Trim());
				text = "医生数量";
				医生数量 = int.Parse(Config.IniReadValue("GameServer", "医生数量").Trim());
				text = "弓箭手数量";
				弓箭手数量 = int.Parse(Config.IniReadValue("GameServer", "弓箭手数量").Trim());
				text = "刀客经验减少";
				刀客经验减少 = double.Parse(Config.IniReadValue("GameServer", "刀客经验减少").Trim());
				text = "剑客经验减少";
				剑客经验减少 = double.Parse(Config.IniReadValue("GameServer", "剑客经验减少").Trim());
				text = "枪客经验减少";
				枪客经验减少 = double.Parse(Config.IniReadValue("GameServer", "枪客经验减少").Trim());
				text = "医生经验减少";
				医生经验减少 = double.Parse(Config.IniReadValue("GameServer", "医生经验减少").Trim());
				text = "弓箭手经验减少";
				弓箭手经验减少 = double.Parse(Config.IniReadValue("GameServer", "弓箭手经验减少").Trim());
				text = "老公提示内容";
				老公提示内容 = Config.IniReadValue("GameServer", "老公提示内容").Trim();
				text = "老婆提示内容";
				老婆提示内容 = Config.IniReadValue("GameServer", "老婆提示内容").Trim();
				text = "夫妻经验爆率增加";
				夫妻经验爆率增加 = Config.IniReadValue("GameServer", "夫妻经验爆率增加").Trim();
				text = "进入公告";
				进入公告 = Config.IniReadValue("GameServer", "进入公告").Trim();
				text = "进入传书";
				进入传书 = Config.IniReadValue("GameServer", "进入传书").Trim();
				text = "百宝阁地址";
				百宝阁地址 = Config.IniReadValue("GameServer", "百宝阁地址").Trim();
				text = "服务器名";
				服务器名 = Config.IniReadValue("GameServer", "服务器名").Trim();
				text = "冲关地图";
				冲关地图 = Config.IniReadValue("GameServer", "冲关地图").Trim();
				text = "门派公告";
				门派公告 = ((Config.IniReadValue("GameServer", "门派公告").Trim() == "") ? 门派公告 : Config.IniReadValue("GameServer", "门派公告").Trim());
				text = "势力战准备时间分钟";
				势力战准备时间分钟 = int.Parse(Config.IniReadValue("GameServer", "势力战准备时间分钟").Trim());
				text = "新手上线礼包";
				新手上线礼包 = ((Config.IniReadValue("GameServer", "新手上线礼包").Trim().Length == 0) ? 新手上线礼包 : int.Parse(Config.IniReadValue("GameServer", "新手上线礼包").Trim()));
				text = "最大移动速度";
				移动速度 = Config.IniReadValue("GameServer", "最大移动速度").Trim().Split(';');
				走 = float.Parse(移动速度[0]);
				跑 = float.Parse(移动速度[1]);
				轻功15 = float.Parse(移动速度[2]);
				轻功60 = float.Parse(移动速度[3]);
				轻功100 = float.Parse(移动速度[4]);
				骑宠1 = float.Parse(移动速度[5]);
				骑宠2 = float.Parse(移动速度[6]);
				骑宠3 = float.Parse(移动速度[7]);
				text = "假人门派";
				机器人门主名称一 = ((Config.IniReadValue("GameServer", "机器人门主名称一").Trim() == "") ? 机器人门主名称一 : Config.IniReadValue("GameServer", "机器人门主名称一").Trim());
				机器人帮派名称一 = ((Config.IniReadValue("GameServer", "机器人帮派名称一").Trim() == "") ? 机器人帮派名称一 : Config.IniReadValue("GameServer", "机器人帮派名称一").Trim());
				机器人门主名称二 = ((Config.IniReadValue("GameServer", "机器人门主名称二").Trim() == "") ? 机器人门主名称二 : Config.IniReadValue("GameServer", "机器人门主名称二").Trim());
				机器人帮派名称二 = ((Config.IniReadValue("GameServer", "机器人帮派名称二").Trim() == "") ? 机器人帮派名称二 : Config.IniReadValue("GameServer", "机器人帮派名称二").Trim());
				机器人门主名称三 = ((Config.IniReadValue("GameServer", "机器人门主名称三").Trim() == "") ? 机器人门主名称三 : Config.IniReadValue("GameServer", "机器人门主名称三").Trim());
				机器人帮派名称三 = ((Config.IniReadValue("GameServer", "机器人帮派名称三").Trim() == "") ? 机器人帮派名称三 : Config.IniReadValue("GameServer", "机器人帮派名称三").Trim());
				机器人门主名称四 = ((Config.IniReadValue("GameServer", "机器人门主名称四").Trim() == "") ? 机器人门主名称四 : Config.IniReadValue("GameServer", "机器人门主名称四").Trim());
				机器人帮派名称四 = ((Config.IniReadValue("GameServer", "机器人帮派名称四").Trim() == "") ? 机器人帮派名称四 : Config.IniReadValue("GameServer", "机器人帮派名称四").Trim());
				机器人门主名称五 = ((Config.IniReadValue("GameServer", "机器人门主名称五").Trim() == "") ? 机器人门主名称五 : Config.IniReadValue("GameServer", "机器人门主名称五").Trim());
				机器人帮派名称五 = ((Config.IniReadValue("GameServer", "机器人帮派名称五").Trim() == "") ? 机器人帮派名称五 : Config.IniReadValue("GameServer", "机器人帮派名称五").Trim());
				机器人门主等级 = int.Parse(Config.IniReadValue("GameServer", "机器人门主等级").Trim());
				text = "延迟死亡间隔";
				延迟死亡间隔 = int.Parse(Config.IniReadValue("GameServer", "延迟死亡间隔").Trim());
				text = "当前线路类型";
				当前线路类型 = ((Config.IniReadValue("GameServer", "当前线路类型").Trim() == "") ? 当前线路类型 : int.Parse(Config.IniReadValue("GameServer", "当前线路类型").Trim()));
				try
				{
					int num = int.Parse(Config.IniReadValue("MAINSERVER", "serverCount"));
					ServerList.Clear();
					for (int j = 0; j < num; j++)
					{
						ServerClass serverClass = new ServerClass();
						string[] array = Config.IniReadValue("MAINSERVER", "server" + j.ToString()).Split(',');
						serverClass.SERVER_NAME = array[0];
						serverClass.ServerId = int.Parse(array[1]);
						serverClass.SERVER_PORT = array[2];
						serverClass.Open = int.Parse(array[3]);
						ServerList.Add(serverClass);
					}
				}
				catch (Exception ex)
				{
					Form1.WriteLine(1, "MAINSERVER 读取错误 " + ex.Source);
				}
				text = "宣战区地图参数";
				dt = Config.IniReadValue("GameServer", "宣战区地图参数").Trim().Split(',');
				text = "复仇区地图参数";
				fc = Config.IniReadValue("GameServer", "复仇区地图参数").Trim().Split(',');
				text = "换线收取类型";
				换线收取类型 = int.Parse(Config.IniReadValue("GameServer", "换线收取类型").Trim());
				text = "换线元宝数量";
				换线元宝数量 = int.Parse(Config.IniReadValue("GameServer", "换线元宝数量").Trim());
				text = "换线金币数量";
				换线金币数量 = int.Parse(Config.IniReadValue("GameServer", "换线金币数量").Trim());
				text = "伏魔洞收取类型";
				伏魔洞收取类型 = int.Parse(Config.IniReadValue("GameServer", "伏魔洞收取类型").Trim());
				text = "伏魔洞元宝数量";
				伏魔洞元宝数量 = int.Parse(Config.IniReadValue("GameServer", "伏魔洞元宝数量").Trim());
				text = "伏魔洞金币数量";
				伏魔洞金币数量 = int.Parse(Config.IniReadValue("GameServer", "伏魔洞金币数量").Trim());
				text = "是否开启仓库时间限制";
				是否开启仓库时间限制 = int.Parse(Config.IniReadValue("GameServer", "是否开启仓库时间限制").Trim());
				text = "综合仓库80级";
				综合仓库80级 = Config.IniReadValue("GameServer", "综合仓库80级").Trim().Split(',');
				text = "杀人武勋限制";
				杀人武勋限制 = Config.IniReadValue("GameServer", "杀人武勋限制").Trim().Split(',');
				text = "综合仓库80级以下";
				综合仓库80级以下 = int.Parse(Config.IniReadValue("GameServer", "综合仓库80级以下").Trim());
				text = "仓库操作间隔";
				仓库操作间隔 = ((Config.IniReadValue("GameServer", "仓库操作间隔").Trim() == "") ? 仓库操作间隔 : int.Parse(Config.IniReadValue("GameServer", "仓库操作间隔").Trim()));
				text = "结婚物品ID";
				结婚物品ID = int.Parse(Config.IniReadValue("GameServer", "结婚物品ID").Trim());
				text = "是否开启实时坐标显示";
				是否开启实时坐标显示 = int.Parse(Config.IniReadValue("GameServer", "是否开启实时坐标显示").Trim());
				text = "实时检测距离";
				实时检测距离 = int.Parse(Config.IniReadValue("GameServer", "实时检测距离").Trim());
				text = "限制打坐距离";
				限制打坐距离 = int.Parse(Config.IniReadValue("GameServer", "限制打坐距离").Trim());
				text = "轻功三";
				轻功三 = ((Config.IniReadValue("GameServer", "轻功三") == "") ? 轻功三 : float.Parse(Config.IniReadValue("GameServer", "轻功三")));
				text = "实时移动时间";
				实时移动时间 = ((Config.IniReadValue("GameServer", "实时移动时间") == "") ? 实时移动时间 : int.Parse(Config.IniReadValue("GameServer", "实时移动时间")));
				text = "普通走";
				普通走 = ((Config.IniReadValue("GameServer", "普通走") == "") ? 普通走 : float.Parse(Config.IniReadValue("GameServer", "普通走")));
				text = "轻功一";
				轻功一 = ((Config.IniReadValue("GameServer", "轻功一") == "") ? 轻功一 : float.Parse(Config.IniReadValue("GameServer", "轻功一")));
				text = "轻功二";
				轻功二 = ((Config.IniReadValue("GameServer", "轻功二") == "") ? 轻功二 : float.Parse(Config.IniReadValue("GameServer", "轻功二")));
				text = "宠物普通走";
				宠物普通走 = ((Config.IniReadValue("GameServer", "宠物普通走") == "") ? 宠物普通走 : float.Parse(Config.IniReadValue("GameServer", "宠物普通走")));
				text = "宠物轻功一";
				宠物轻功一 = ((Config.IniReadValue("GameServer", "宠物轻功一") == "") ? 宠物轻功一 : float.Parse(Config.IniReadValue("GameServer", "宠物轻功一")));
				text = "宠物轻功二";
				宠物轻功二 = ((Config.IniReadValue("GameServer", "宠物轻功二") == "") ? 宠物轻功二 : float.Parse(Config.IniReadValue("GameServer", "宠物轻功二")));
				text = "宠物轻功三";
				宠物轻功三 = ((Config.IniReadValue("GameServer", "宠物轻功三") == "") ? 宠物轻功三 : float.Parse(Config.IniReadValue("GameServer", "宠物轻功三")));
				text = "刀打怪攻击百分比";
				刀打怪攻击百分比 = ((Config.IniReadValue("GameServer", "刀打怪攻击百分比").Trim().Length == 0) ? 刀打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "刀打怪攻击百分比").Trim()));
				text = "刀打人攻击百分比";
				刀打人攻击百分比 = ((Config.IniReadValue("GameServer", "刀打人攻击百分比").Trim().Length == 0) ? 刀打人攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "刀打人攻击百分比").Trim()));
				text = "刀客暴率百分比";
				刀客暴率百分比 = ((Config.IniReadValue("GameServer", "刀客暴率百分比").Trim().Length == 0) ? 刀客暴率百分比 : double.Parse(Config.IniReadValue("GameServer", "刀客暴率百分比").Trim()));
				text = "剑打怪攻击百分比";
				剑打怪攻击百分比 = ((Config.IniReadValue("GameServer", "剑打怪攻击百分比").Trim().Length == 0) ? 剑打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "剑打怪攻击百分比").Trim()));
				text = "剑打人攻击百分比";
				剑打人攻击百分比 = ((Config.IniReadValue("GameServer", "剑打人攻击百分比").Trim().Length == 0) ? 剑打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "剑打人攻击百分比").Trim()));
				text = "枪打怪攻击百分比";
				枪打怪攻击百分比 = ((Config.IniReadValue("GameServer", "枪打怪攻击百分比").Trim().Length == 0) ? 枪打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "枪打怪攻击百分比").Trim()));
				text = "枪打人攻击百分比";
				枪打人攻击百分比 = ((Config.IniReadValue("GameServer", "枪打人攻击百分比").Trim().Length == 0) ? 枪打人攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "枪打人攻击百分比").Trim()));
				text = "弓打怪攻击百分比";
				弓打怪攻击百分比 = ((Config.IniReadValue("GameServer", "弓打怪攻击百分比").Trim().Length == 0) ? 弓打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "弓打怪攻击百分比").Trim()));
				text = "弓打人攻击百分比";
				弓打人攻击百分比 = ((Config.IniReadValue("GameServer", "弓打人攻击百分比").Trim().Length == 0) ? 弓打人攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "弓打人攻击百分比").Trim()));
				text = "医打怪攻击百分比";
				医打怪攻击百分比 = ((Config.IniReadValue("GameServer", "医打怪攻击百分比").Trim().Length == 0) ? 医打怪攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "医打怪攻击百分比").Trim()));
				text = "医打人攻击百分比";
				医打人攻击百分比 = ((Config.IniReadValue("GameServer", "医打人攻击百分比").Trim().Length == 0) ? 医打人攻击百分比 : double.Parse(Config.IniReadValue("GameServer", "医打人攻击百分比").Trim()));
				text = "是否开启共用银币市场";
				是否开启共用银币市场 = ((Config.IniReadValue("GameServer", "是否开启共用银币市场").Trim() == "") ? 是否开启共用银币市场 : int.Parse(Config.IniReadValue("GameServer", "是否开启共用银币市场").Trim()));
				text = "换线存档方式";
				换线存档方式 = ((Config.IniReadValue("GameServer", "换线存档方式").Trim() == "") ? 换线存档方式 : int.Parse(Config.IniReadValue("GameServer", "换线存档方式").Trim()));
				text = "换线移动间隔";
				换线移动间隔 = ((Config.IniReadValue("GameServer", "换线移动间隔").Trim() == "") ? 换线移动间隔 : int.Parse(Config.IniReadValue("GameServer", "换线移动间隔").Trim()));
				text = "银币服务器IP";
				银币服务器IP = Config.IniReadValue("GameServer", "银币服务器IP").Trim();
				text = "银币服务器IP2";
				银币服务器IP2 = Config.IniReadValue("GameServer", "银币服务器IP2").Trim();
				text = "银币服务器PORT";
				银币服务器PORT = Config.IniReadValue("GameServer", "银币服务器PORT").Trim();
				text = "主服务器PORT";
				主服务器PORT = Config.IniReadValue("GameServer", "主服务器PORT").Trim();
				text = "禁止出售物品1";
				禁止出售物品1 = ((Config.IniReadValue("GameServer", "禁止出售物品1").Trim().Length == 0) ? 禁止出售物品1 : int.Parse(Config.IniReadValue("GameServer", "禁止出售物品1").Trim()));
				text = "禁止出售物品2";
				禁止出售物品2 = ((Config.IniReadValue("GameServer", "禁止出售物品2").Trim().Length == 0) ? 禁止出售物品2 : int.Parse(Config.IniReadValue("GameServer", "禁止出售物品2").Trim()));
				text = "禁止出售物品3";
				禁止出售物品3 = ((Config.IniReadValue("GameServer", "禁止出售物品3").Trim().Length == 0) ? 禁止出售物品3 : int.Parse(Config.IniReadValue("GameServer", "禁止出售物品3").Trim()));
				text = "禁止出售物品4";
				禁止出售物品4 = ((Config.IniReadValue("GameServer", "禁止出售物品4").Trim().Length == 0) ? 禁止出售物品4 : int.Parse(Config.IniReadValue("GameServer", "禁止出售物品4").Trim()));
				text = "禁止出售物品5";
				禁止出售物品5 = ((Config.IniReadValue("GameServer", "禁止出售物品5").Trim().Length == 0) ? 禁止出售物品5 : int.Parse(Config.IniReadValue("GameServer", "禁止出售物品5").Trim()));
				text = "势力战奖励个人物品";
				势力战奖励个人物品 = ((Config.IniReadValue("GameServer", "势力战奖励个人物品").Trim() == "") ? 势力战奖励个人物品 : Config.IniReadValue("GameServer", "势力战奖励个人物品").Trim());
				text = "游戏登陆端口最大连接数";
				游戏登陆端口最大连接数 = ((Config.IniReadValue("GameServer", "游戏登陆端口最大连接数") == "") ? 游戏登陆端口最大连接数 : int.Parse(Config.IniReadValue("GameServer", "游戏登陆端口最大连接数")));
				text = "游戏登陆端口最大连接时间数";
				游戏登陆端口最大连接时间数 = ((Config.IniReadValue("GameServer", "游戏登陆端口最大连接时间数") == "") ? 游戏登陆端口最大连接时间数 : int.Parse(Config.IniReadValue("GameServer", "游戏登陆端口最大连接时间数")));
				text = "自动连接时间";
				自动连接时间 = ((Config.IniReadValue("GameServer", "自动连接时间") == "") ? 自动连接时间 : int.Parse(Config.IniReadValue("GameServer", "自动连接时间")));
				text = "封IP";
				封IP = (Config.IniReadValue("GameServer", "封IP").Trim().ToLower() == "true");
				text = "神珍大宝汤";
				神珍大宝汤 = int.Parse(Config.IniReadValue("GameServer", "神珍大宝汤").Trim());
				text = "自动开启换端口";
				自动开启换端口 = (Config.IniReadValue("GameServer", "自动开启换端口").Trim().ToLower() == "true");
				text = "允许最大连接数";
				允许最大连接数 = ((Config.IniReadValue("GameServer", "允许最大连接数") == "") ? 允许最大连接数 : int.Parse(Config.IniReadValue("GameServer", "允许最大连接数")));
				text = "断开连接";
				断开连接 = (Config.IniReadValue("GameServer", "断开连接").Trim().ToLower() == "true");
				text = "加入过滤列表";
				加入过滤列表 = (Config.IniReadValue("GameServer", "加入过滤列表").Trim().ToLower() == "true");
				text = "关闭连接";
				关闭连接 = (Config.IniReadValue("GameServer", "关闭连接").Trim().ToLower() == "true");
				text = "经验倍数";
				经验倍数 = ((Config.IniReadValue("GameServer", "经验倍数").Trim() == "") ? 经验倍数 : double.Parse(Config.IniReadValue("GameServer", "经验倍数").Trim()));
				text = "钱倍数";
				钱倍数 = ((Config.IniReadValue("GameServer", "钱倍数").Trim() == "") ? 钱倍数 : double.Parse(Config.IniReadValue("GameServer", "钱倍数").Trim()));
				text = "历练倍数";
				历练倍数 = ((Config.IniReadValue("GameServer", "历练倍数").Trim() == "") ? 历练倍数 : double.Parse(Config.IniReadValue("GameServer", "历练倍数").Trim()));
				text = "暴率";
				暴率 = ((Config.IniReadValue("GameServer", "暴率").Trim() == "") ? 暴率 : int.Parse(Config.IniReadValue("GameServer", "暴率").Trim()));
				text = "获得经验等级差上线";
				获得经验等级差上线 = ((Config.IniReadValue("GameServer", "获得经验等级差上线").Trim() == "") ? 获得经验等级差上线 : int.Parse(Config.IniReadValue("GameServer", "获得经验等级差上线").Trim()));
				text = "获得经验等级差下线";
				获得经验等级差下线 = int.Parse(Config.IniReadValue("GameServer", "获得经验等级差下线").Trim());
				text = "最大在线";
				最大在线 = ((Config.IniReadValue("GameServer", "最大在线").Trim() == "") ? 最大在线 : int.Parse(Config.IniReadValue("GameServer", "最大在线").Trim()));
				text = "服务器组ID";
				服务器组ID = ((Config.IniReadValue("GameServer", "服务器组ID").Trim() == "") ? 服务器组ID : int.Parse(Config.IniReadValue("GameServer", "服务器组ID").Trim()));
				text = "服务器ID";
				服务器ID = ((Config.IniReadValue("GameServer", "服务器ID").Trim() == "") ? 服务器ID : int.Parse(Config.IniReadValue("GameServer", "服务器ID").Trim()));
				text = "游戏服务器端口";
				游戏服务器端口 = ((Config.IniReadValue("GameServer", "游戏服务器端口").Trim() == "") ? 游戏服务器端口 : int.Parse(Config.IniReadValue("GameServer", "游戏服务器端口").Trim()));
				text = "转发器网关服务端口";
				转发器网关服务端口 = ((Config.IniReadValue("GameServer", "转发器网关服务端口").Trim() == "") ? 转发器网关服务端口 : int.Parse(Config.IniReadValue("GameServer", "转发器网关服务端口").Trim()));
				text = "高倍经验开启时间";
				高倍经验开启时间 = ((Config.IniReadValue("GameServer", "高倍经验开启时间").Trim() == "") ? 高倍经验开启时间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验开启时间").Trim()));
				text = "高倍经验开启分间";
				高倍经验开启分间 = ((Config.IniReadValue("GameServer", "高倍经验开启分间").Trim() == "") ? 高倍经验开启分间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验开启分间").Trim()));
				text = "高倍经验开启秒间";
				高倍经验开启秒间 = ((Config.IniReadValue("GameServer", "高倍经验开启秒间").Trim() == "") ? 高倍经验开启秒间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验开启秒间").Trim()));
				text = "高倍经验结束时间";
				高倍经验结束时间 = ((Config.IniReadValue("GameServer", "高倍经验结束时间").Trim() == "") ? 高倍经验结束时间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验结束时间").Trim()));
				text = "高倍经验结束分间";
				高倍经验结束分间 = ((Config.IniReadValue("GameServer", "高倍经验结束分间").Trim() == "") ? 高倍经验结束分间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验结束分间").Trim()));
				text = "高倍经验结束秒间";
				高倍经验结束秒间 = ((Config.IniReadValue("GameServer", "高倍经验结束秒间").Trim() == "") ? 高倍经验结束秒间 : int.Parse(Config.IniReadValue("GameServer", "高倍经验结束秒间").Trim()));
				text = "高倍经验倍数";
				高倍经验倍数 = ((Config.IniReadValue("GameServer", "高倍经验倍数").Trim() == "") ? 高倍经验倍数 : double.Parse(Config.IniReadValue("GameServer", "高倍经验倍数").Trim()));
				text = "是否封杀锁人功能";
				是否封杀锁人功能 = ((Config.IniReadValue("GameServer", "是否封杀锁人功能").Trim() == "") ? 是否封杀锁人功能 : int.Parse(Config.IniReadValue("GameServer", "是否封杀锁人功能").Trim()));
				text = "是否限制无限躺尸";
				是否限制无限躺尸 = ((Config.IniReadValue("GameServer", "是否限制无限躺尸").Trim() == "") ? 是否限制无限躺尸 : int.Parse(Config.IniReadValue("GameServer", "是否限制无限躺尸").Trim()));
				text = "开启限制武勋上限";
				开启限制武勋上限 = int.Parse(Config.IniReadValue("GameServer", "开启限制武勋上限").Trim());
				text = "吃武勋上限数值";
				吃武勋上限数值 = long.Parse(Config.IniReadValue("GameServer", "吃武勋上限数值").Trim());
				text = "限制远程打开NPC";
				限制远程打开NPC = ((Config.IniReadValue("GameServer", "限制远程打开NPC").Trim() == "") ? 限制远程打开NPC : int.Parse(Config.IniReadValue("GameServer", "限制远程打开NPC").Trim()));
				text = "打开NPC限制距离";
				打开NPC限制距离 = ((Config.IniReadValue("GameServer", "打开NPC限制距离").Trim() == "") ? 打开NPC限制距离 : int.Parse(Config.IniReadValue("GameServer", "打开NPC限制距离").Trim()));
				text = "限制连环飞舞确认时间";
				限制连环飞舞确认时间 = ((Config.IniReadValue("GameServer", "限制连环飞舞确认时间").Trim() == "") ? 限制连环飞舞确认时间 : int.Parse(Config.IniReadValue("GameServer", "限制连环飞舞确认时间").Trim()));
				text = "全局测试模式";
				全局测试模式 = ((Config.IniReadValue("GameServer", "全局测试模式").Trim() == "") ? 全局测试模式 : int.Parse(Config.IniReadValue("GameServer", "全局测试模式").Trim()));
				text = "连续快速攻击次数";
				连续快速攻击次数 = ((Config.IniReadValue("GameServer", "连续快速攻击次数").Trim() == "") ? 连续快速攻击次数 : int.Parse(Config.IniReadValue("GameServer", "连续快速攻击次数").Trim()));
				text = "非法攻击外挂操作";
				非法攻击外挂操作 = ((Config.IniReadValue("GameServer", "非法攻击外挂操作").Trim() == "") ? 非法攻击外挂操作 : int.Parse(Config.IniReadValue("GameServer", "非法攻击外挂操作").Trim()));
				text = "怪物移动最大范围";
				怪物移动最大范围 = ((Config.IniReadValue("GameServer", "怪物移动最大范围").Trim() == "") ? 怪物移动最大范围 : float.Parse(Config.IniReadValue("GameServer", "怪物移动最大范围").Trim()));
				text = "银币移动测试封包";
				银币移动测试封包 = ((Config.IniReadValue("GameServer", "银币移动测试封包").Trim() == "") ? 银币移动测试封包 : int.Parse(Config.IniReadValue("GameServer", "银币移动测试封包").Trim()));
				text = "南明湖经验倍数";
				南明湖经验倍数 = ((Config.IniReadValue("GameServer", "南明湖经验倍数").Trim() == "") ? 南明湖经验倍数 : double.Parse(Config.IniReadValue("GameServer", "南明湖经验倍数").Trim()));
				text = "北海经验倍数";
				北海经验倍数 = ((Config.IniReadValue("GameServer", "北海经验倍数").Trim() == "") ? 北海经验倍数 : double.Parse(Config.IniReadValue("GameServer", "北海经验倍数").Trim()));
				text = "满职业经验增加";
				满职业经验增加 = ((Config.IniReadValue("GameServer", "满职业经验增加").Trim() == "") ? 满职业经验增加 : double.Parse(Config.IniReadValue("GameServer", "满职业经验增加").Trim()));
				text = "第一阶段经验倍数";
				第一阶段经验倍数 = ((Config.IniReadValue("GameServer", "第一阶段经验倍数").Trim() == "") ? 第一阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第一阶段经验倍数").Trim()));
				text = "第二阶段经验倍数";
				第二阶段经验倍数 = ((Config.IniReadValue("GameServer", "第二阶段经验倍数").Trim() == "") ? 第二阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第二阶段经验倍数").Trim()));
				text = "第三阶段经验倍数";
				第三阶段经验倍数 = ((Config.IniReadValue("GameServer", "第三阶段经验倍数").Trim() == "") ? 第三阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第三阶段经验倍数").Trim()));
				text = "第四阶段经验倍数";
				第四阶段经验倍数 = ((Config.IniReadValue("GameServer", "第四阶段经验倍数").Trim() == "") ? 第四阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第四阶段经验倍数").Trim()));
				text = "第五阶段经验倍数";
				第五阶段经验倍数 = ((Config.IniReadValue("GameServer", "第五阶段经验倍数").Trim() == "") ? 第五阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第五阶段经验倍数").Trim()));
				text = "第六阶段经验倍数";
				第六阶段经验倍数 = ((Config.IniReadValue("GameServer", "第六阶段经验倍数").Trim() == "") ? 第六阶段经验倍数 : double.Parse(Config.IniReadValue("GameServer", "第六阶段经验倍数").Trim()));
				text = "历练获得降低百分比";
				历练获得降低百分比 = double.Parse(Config.IniReadValue("GameServer", "历练获得降低百分比").Trim());
				text = "经验获得降低百分比";
				经验获得降低百分比 = double.Parse(Config.IniReadValue("GameServer", "经验获得降低百分比").Trim());
				text = "满职业经验增加是否开启";
				满职业经验增加是否开启 = int.Parse(Config.IniReadValue("GameServer", "满职业经验增加是否开启").Trim());
				text = "自定义等级一阶段";
				自定义等级一阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级一阶段").Trim());
				text = "自定义等级二阶段";
				自定义等级二阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级二阶段").Trim());
				text = "自定义等级三阶段";
				自定义等级三阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级三阶段").Trim());
				text = "自定义等级四阶段";
				自定义等级四阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级四阶段").Trim());
				text = "自定义等级五阶段";
				自定义等级五阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级五阶段").Trim());
				text = "自定义等级六阶段";
				自定义等级六阶段 = int.Parse(Config.IniReadValue("GameServer", "自定义等级六阶段").Trim());
				text = "百宝阁服务器端口";
				百宝阁服务器端口 = ((Config.IniReadValue("GameServer", "百宝阁服务器端口").Trim() == "") ? 百宝阁服务器端口 : int.Parse(Config.IniReadValue("GameServer", "百宝阁服务器端口").Trim()));
				text = "帐号验证服务器端口";
				帐号验证服务器端口 = ((Config.IniReadValue("GameServer", "帐号验证服务器端口").Trim() == "") ? 帐号验证服务器端口 : int.Parse(Config.IniReadValue("GameServer", "帐号验证服务器端口").Trim()));
				text = "帐号验证服务器IP";
				帐号验证服务器IP = Config.IniReadValue("GameServer", "帐号验证服务器IP").Trim();
				text = "vip线";
				vip线 = ((!(Config.IniReadValue("GameServer", "vip线").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "vip线").Trim()) : 0);
				text = "PK开关";
				PK开关 = ((!(Config.IniReadValue("GameServer", "PK开关").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "PK开关").Trim()) : 0);
				text = "购买间隔";
				购买间隔 = ((Config.IniReadValue("GameServer", "购买间隔").Trim() == "") ? 购买间隔 : int.Parse(Config.IniReadValue("GameServer", "购买间隔").Trim()));
				text = "交易完成间隔";
				交易完成间隔 = ((Config.IniReadValue("GameServer", "交易完成间隔").Trim() == "") ? 交易完成间隔 : int.Parse(Config.IniReadValue("GameServer", "交易完成间隔").Trim()));
				text = "交易放物品间隔";
				交易放物品间隔 = ((Config.IniReadValue("GameServer", "交易放物品间隔").Trim() == "") ? 交易放物品间隔 : int.Parse(Config.IniReadValue("GameServer", "交易放物品间隔").Trim()));
				text = "是否限制加速器";
				是否限制加速器 = ((Config.IniReadValue("GameServer", "是否限制加速器").Trim() == "") ? 是否限制加速器 : int.Parse(Config.IniReadValue("GameServer", "是否限制加速器").Trim()));
				text = "是否校验机器码";
				是否校验机器码 = ((Config.IniReadValue("GameServer", "是否校验机器码").Trim() == "") ? 是否校验机器码 : int.Parse(Config.IniReadValue("GameServer", "是否校验机器码").Trim()));
				text = "加速检查次数";
				加速检查次数 = ((Config.IniReadValue("GameServer", "加速检查次数").Trim() == "") ? 加速检查次数 : int.Parse(Config.IniReadValue("GameServer", "加速检查次数").Trim()));
				text = "限制加速器时间";
				限制加速器时间 = ((Config.IniReadValue("GameServer", "限制加速器时间").Trim() == "") ? 限制加速器时间 : int.Parse(Config.IniReadValue("GameServer", "限制加速器时间").Trim()));
				text = "外挂锁人时间";
				外挂锁人时间 = ((Config.IniReadValue("GameServer", "外挂锁人时间").Trim() == "") ? 外挂锁人时间 : int.Parse(Config.IniReadValue("GameServer", "外挂锁人时间").Trim()));
				text = "外挂检测操作";
				外挂检测操作 = ((Config.IniReadValue("GameServer", "外挂检测操作").Trim() == "") ? 外挂检测操作 : int.Parse(Config.IniReadValue("GameServer", "外挂检测操作").Trim()));
				text = "攻击加速检查次数";
				攻击加速检查次数 = ((Config.IniReadValue("GameServer", "攻击加速检查次数").Trim() == "") ? 攻击加速检查次数 : int.Parse(Config.IniReadValue("GameServer", "攻击加速检查次数").Trim()));
				text = "武功连击有效时间";
				武功连击有效时间 = ((Config.IniReadValue("GameServer", "武功连击有效时间").Trim() == "") ? 武功连击有效时间 : int.Parse(Config.IniReadValue("GameServer", "武功连击有效时间").Trim()));
				text = "武功连击冷却时间";
				武功连击冷却时间 = ((Config.IniReadValue("GameServer", "武功连击冷却时间").Trim() == "") ? 武功连击冷却时间 : int.Parse(Config.IniReadValue("GameServer", "武功连击冷却时间").Trim()));
				text = "连续攻击有效时间";
				连续攻击有效时间 = ((Config.IniReadValue("GameServer", "连续攻击有效时间").Trim() == "") ? 连续攻击有效时间 : int.Parse(Config.IniReadValue("GameServer", "连续攻击有效时间").Trim()));
				text = "限制技能优化";
				限制技能优化 = ((Config.IniReadValue("GameServer", "限制技能优化").Trim() == "") ? 限制技能优化 : int.Parse(Config.IniReadValue("GameServer", "限制技能优化").Trim()));
				text = "封杀打坐杀怪";
				封杀打坐杀怪 = (Config.IniReadValue("GameServer", "封杀打坐杀怪").Trim().ToLower() == "true");
				text = "封杀无限打坐卡技能";
				封杀无限打坐卡技能 = (Config.IniReadValue("GameServer", "封杀无限打坐卡技能").Trim().ToLower() == "true");
				text = "是否开启BOSS挑战";
				是否开启BOSS挑战 = ((Config.IniReadValue("GameServer", "是否开启BOSS挑战").Trim() == "") ? 是否开启BOSS挑战 : int.Parse(Config.IniReadValue("GameServer", "是否开启BOSS挑战").Trim()));
				text = "是否开启门派正邪";
				是否开启门派正邪 = ((Config.IniReadValue("GameServer", "是否开启门派正邪").Trim() == "") ? 是否开启门派正邪 : int.Parse(Config.IniReadValue("GameServer", "是否开启门派正邪").Trim()));
				text = "吃金符是否送15符";
				吃金符是否送15符 = ((Config.IniReadValue("GameServer", "是否开启BOSS挑战").Trim() == "") ? 吃金符是否送15符 : int.Parse(Config.IniReadValue("GameServer", "吃金符是否送15符").Trim()));
				text = "移动加速检查速度";
				try
				{
					string text2 = Config.IniReadValue("GameServer", "移动加速检查速度").Trim();
					if (text2 != "")
					{
						string[] array2 = text2.Split(';');
						if (array2.Length > 5)
						{
							for (int k = 0; k < array2.Length; k++)
							{
								移动加速检查速度[k] = float.Parse(array2[k]);
							}
						}
					}
				}
				catch (Exception ex2)
				{
					Form1.WriteLine(1, "移动加速检查速度读取错误 " + ex2.Source);
				}
				text = "组队获得经验范围";
				组队获得经验范围 = ((Config.IniReadValue("GameServer", "组队获得经验范围").Trim() == "") ? 组队获得经验范围 : int.Parse(Config.IniReadValue("GameServer", "组队获得经验范围").Trim()));
				text = "隔体传功是否开启";
				隔体传功是否开启 = ((Config.IniReadValue("GameServer", "隔体传功是否开启").Trim() == "") ? 隔体传功是否开启 : int.Parse(Config.IniReadValue("GameServer", "隔体传功是否开启").Trim()));
				text = "移动加速检查次数";
				移动加速检查次数 = ((Config.IniReadValue("GameServer", "移动加速检查次数").Trim() == "") ? 移动加速检查次数 : int.Parse(Config.IniReadValue("GameServer", "移动加速检查次数").Trim()));
				text = "移动加速检查周期";
				移动加速检查周期 = ((Config.IniReadValue("GameServer", "移动加速检查周期").Trim() == "") ? 移动加速检查周期 : int.Parse(Config.IniReadValue("GameServer", "移动加速检查周期").Trim()));
				text = "是否上线发送礼品";
				是否上线发送礼品 = ((Config.IniReadValue("GameServer", "是否上线发送礼品").Trim() == "") ? 是否上线发送礼品 : int.Parse(Config.IniReadValue("GameServer", "是否上线发送礼品").Trim()));
				text = "新老玩家回归奖励";
				新老玩家回归奖励 = ((Config.IniReadValue("GameServer", "新老玩家回归奖励").Trim() == "") ? 新老玩家回归奖励 : int.Parse(Config.IniReadValue("GameServer", "新老玩家回归奖励").Trim()));
				text = "老玩家回归等级限制";
				老玩家回归等级限制 = ((Config.IniReadValue("GameServer", "老玩家回归等级限制").Trim() == "") ? 老玩家回归等级限制 : int.Parse(Config.IniReadValue("GameServer", "老玩家回归等级限制").Trim()));
				text = "上线礼品标识码";
				上线礼品标识码 = ((Config.IniReadValue("GameServer", "上线礼品标识码").Trim() == "") ? 上线礼品标识码 : int.Parse(Config.IniReadValue("GameServer", "上线礼品标识码").Trim()));
				text = "狮吼功元宝金币切换开关";
				狮吼功元宝金币切换开关 = ((Config.IniReadValue("GameServer", "狮吼功元宝金币切换开关").Trim() == "") ? 狮吼功元宝金币切换开关 : int.Parse(Config.IniReadValue("GameServer", "狮吼功元宝金币切换开关").Trim()));
				text = "狮吼功需要元宝";
				狮吼功需要元宝 = ((Config.IniReadValue("GameServer", "狮吼功需要元宝").Trim() == "") ? 狮吼功需要元宝 : int.Parse(Config.IniReadValue("GameServer", "狮吼功需要元宝").Trim()));
				text = "狮吼功需要游戏币";
				狮吼功需要游戏币 = ((Config.IniReadValue("GameServer", "狮吼功需要游戏币").Trim() == "") ? 狮吼功需要游戏币 : int.Parse(Config.IniReadValue("GameServer", "狮吼功需要游戏币").Trim()));
				text = "势力战是否开启";
				势力战是否开启 = ((Config.IniReadValue("GameServer", "势力战是否开启").Trim() == "") ? 势力战是否开启 : int.Parse(Config.IniReadValue("GameServer", "势力战是否开启").Trim()));
				text = "势力战是否开启";
				if (势力战是否开启 == 1)
				{
					text = "三转势力战开启小时";
					三转势力战开启小时 = int.Parse(Config.IniReadValue("GameServer", "三转势力战开启小时").Trim());
					text = "四转势力战开启小时";
					四转势力战开启小时 = int.Parse(Config.IniReadValue("GameServer", "四转势力战开启小时").Trim());
					text = "势力战开启分";
					势力战开启分 = int.Parse(Config.IniReadValue("GameServer", "势力战开启分").Trim());
					text = "势力战开启秒";
					势力战开启秒 = int.Parse(Config.IniReadValue("GameServer", "势力战开启秒").Trim());
				}
				text = "势力战时长";
				势力战时长 = int.Parse(Config.IniReadValue("GameServer", "势力战时长").Trim());
				text = "势力战随机奖励物品";
				势力战随机奖励物品 = ((Config.IniReadValue("GameServer", "势力战随机奖励物品").Trim().Length == 0) ? 势力战随机奖励物品 : int.Parse(Config.IniReadValue("GameServer", "势力战随机奖励物品").Trim()));
				text = "势力战前五名奖励武勋";
				势力战前五名奖励武勋 = ((Config.IniReadValue("GameServer", "势力战前五名奖励武勋").Trim().Length == 0) ? 势力战前五名奖励武勋 : int.Parse(Config.IniReadValue("GameServer", "势力战前五名奖励武勋").Trim()));
				text = "势力战五到十名奖励武勋";
				势力战五到十名奖励武勋 = ((Config.IniReadValue("GameServer", "势力战五到十名奖励武勋").Trim().Length == 0) ? 势力战五到十名奖励武勋 : int.Parse(Config.IniReadValue("GameServer", "势力战五到十名奖励武勋").Trim()));
				text = "势力战十到二十名奖励武勋";
				势力战十到二十名奖励武勋 = ((Config.IniReadValue("GameServer", "势力战十到二十名奖励武勋").Trim().Length == 0) ? 势力战十到二十名奖励武勋 : int.Parse(Config.IniReadValue("GameServer", "势力战十到二十名奖励武勋").Trim()));
				text = "势力战二十到五十名奖励武勋";
				势力战二十到五十名奖励武勋 = ((Config.IniReadValue("GameServer", "势力战二十到五十名奖励武勋").Trim().Length == 0) ? 势力战二十到五十名奖励武勋 : int.Parse(Config.IniReadValue("GameServer", "势力战二十到五十名奖励武勋").Trim()));
				text = "势力战基础奖励武勋";
				势力战基础奖励武勋 = ((Config.IniReadValue("GameServer", "势力战基础奖励武勋").Trim().Length == 0) ? 势力战基础奖励武勋 : int.Parse(Config.IniReadValue("GameServer", "势力战基础奖励武勋").Trim()));
				text = "假人上线初始武勋";
				假人上线初始武勋 = ((Config.IniReadValue("GameServer", "假人上线初始武勋").Trim().Length == 0) ? 假人上线初始武勋 : int.Parse(Config.IniReadValue("GameServer", "假人上线初始武勋").Trim()));
				text = "势力战限制进入时间";
				势力战限制进入时间 = ((Config.IniReadValue("GameServer", "势力战限制进入时间").Trim() == "") ? 势力战限制进入时间 : int.Parse(Config.IniReadValue("GameServer", "势力战限制进入时间").Trim()));
				text = "门战是否开启";
				门战是否开启 = ((Config.IniReadValue("GameServer", "门战是否开启").Trim() == "") ? 门战是否开启 : int.Parse(Config.IniReadValue("GameServer", "门战是否开启").Trim()));
				text = "门战地图";
				门战地图 = ((Config.IniReadValue("GameServer", "门战地图").Trim() == "") ? 门战地图 : int.Parse(Config.IniReadValue("GameServer", "门战地图").Trim()));
				text = "门战开启小时1";
				门战开启小时1 = ((Config.IniReadValue("GameServer", "门战开启小时").Trim() == "") ? 门战开启小时1 : int.Parse(Config.IniReadValue("GameServer", "门战开启小时").Trim()));
				text = "门战限制等级";
				门战限制等级 = ((Config.IniReadValue("GameServer", "门战限制等级").Trim() == "") ? 门战限制等级 : int.Parse(Config.IniReadValue("GameServer", "门战限制等级").Trim()));
				text = "门战需要金币";
				门战需要金币 = ((Config.IniReadValue("GameServer", "门战需要金币").Trim() == "") ? 门战需要金币 : int.Parse(Config.IniReadValue("GameServer", "门战需要金币").Trim()));
				text = "获胜门派获得武勋";
				获胜门派获得武勋 = ((Config.IniReadValue("GameServer", "获胜门派获得武勋").Trim() == "") ? 获胜门派获得武勋 : int.Parse(Config.IniReadValue("GameServer", "获胜门派获得武勋").Trim()));
				text = "失败门派获得武勋";
				失败门派获得武勋 = ((Config.IniReadValue("GameServer", "失败门派获得武勋").Trim() == "") ? 失败门派获得武勋 : int.Parse(Config.IniReadValue("GameServer", "失败门派获得武勋").Trim()));
				text = "门站随机奖励物品";
				门站随机奖励物品 = ((Config.IniReadValue("GameServer", "门站随机奖励物品").Trim() == "") ? 门站随机奖励物品 : Config.IniReadValue("GameServer", "门站随机奖励物品").Trim());
				text = "门站随机奖励物品";
				门站BOSS = ((Config.IniReadValue("GameServer", "门站BOSS").Trim() == "") ? 门站BOSS : Config.IniReadValue("GameServer", "门站BOSS").Trim());
				text = "副本开始时间";
				副本开始时间 = ((Config.IniReadValue("GameServer", "副本开始时间").Trim() == "") ? 副本开始时间 : int.Parse(Config.IniReadValue("GameServer", "副本开始时间").Trim()));
				text = "副本结束时间";
				副本结束时间 = ((Config.IniReadValue("GameServer", "副本结束时间").Trim() == "") ? 副本结束时间 : int.Parse(Config.IniReadValue("GameServer", "副本结束时间").Trim()));
				text = "副本开启状态";
				副本开启状态 = ((Config.IniReadValue("GameServer", "副本开启状态").Trim() == "") ? 副本开启状态 : int.Parse(Config.IniReadValue("GameServer", "副本开启状态").Trim()));
				text = "副本限制次数";
				副本限制次数 = ((Config.IniReadValue("GameServer", "副本限制次数").Trim() == "") ? 副本限制次数 : int.Parse(Config.IniReadValue("GameServer", "副本限制次数").Trim()));
				text = "封包异步发送";
				封包异步发送 = ((Config.IniReadValue("GameServer", "封包异步发送") == "") ? 封包异步发送 : int.Parse(Config.IniReadValue("GameServer", "封包异步发送")));
				text = "狮子吼最大数";
				狮子吼最大数 = ((Config.IniReadValue("GameServer", "狮子吼最大数") == "") ? 狮子吼最大数 : int.Parse(Config.IniReadValue("GameServer", "狮子吼最大数")));
				text = "是否加密";
				是否加密 = ((Config.IniReadValue("GameServer", "是否加密").Trim() == "") ? 是否加密 : int.Parse(Config.IniReadValue("GameServer", "是否加密").Trim()));
				text = "登陆器模式";
				登陆器模式 = int.Parse(Config.IniReadValue("GameServer", "登陆器模式").Trim());
				text = "使用共享华夏登陆器";
				使用共享华夏登陆器 = int.Parse(Config.IniReadValue("GameServer", "使用共享华夏登陆器").Trim());
				text = "排位赛开启时";
				乱斗开启时 = int.Parse(Config.IniReadValue("GameServer", "排位赛开启时").Trim());
				text = "排位赛开启分";
				乱斗开启分 = int.Parse(Config.IniReadValue("GameServer", "排位赛开启分").Trim());
				text = "排位赛开启秒";
				乱斗开启秒 = int.Parse(Config.IniReadValue("GameServer", "排位赛开启秒").Trim());
				text = "排位赛系统是否开启";
				乱斗系统是否开启 = int.Parse(Config.IniReadValue("GameServer", "排位赛系统是否开启").Trim());
				text = "排位赛奖励是否开启";
				乱斗奖励是否开启 = int.Parse(Config.IniReadValue("GameServer", "排位赛奖励是否开启").Trim());
				text = "排位赛地图";
				乱斗地图 = int.Parse(Config.IniReadValue("GameServer", "排位赛地图").Trim());
				text = "排位赛地区X坐标";
				乱斗地区X坐标 = float.Parse(Config.IniReadValue("GameServer", "排位赛地区X坐标").Trim());
				text = "排位赛地区Y坐标";
				乱斗地区Y坐标 = float.Parse(Config.IniReadValue("GameServer", "排位赛地区Y坐标").Trim());
				text = "排位赛地区范围";
				乱斗地区范围 = int.Parse(Config.IniReadValue("GameServer", "排位赛地区范围").Trim());
				text = "排位赛倒计时";
				乱斗倒计时 = int.Parse(Config.IniReadValue("GameServer", "排位赛倒计时").Trim());
				text = "排位赛战斗时间";
				乱斗战斗时间 = int.Parse(Config.IniReadValue("GameServer", "排位赛战斗时间").Trim());
				text = "排位赛命令";
				乱斗命令 = Config.IniReadValue("GameServer", "排位赛命令").Trim();
				text = "累计击杀奖励1";
				累计击杀奖励1 = Config.IniReadValue("GameServer", "累计击杀奖励1").Trim();
				text = "累计击杀奖励2";
				累计击杀奖励2 = Config.IniReadValue("GameServer", "累计击杀奖励2").Trim();
				text = "累计击杀奖励3";
				累计击杀奖励3 = Config.IniReadValue("GameServer", "累计击杀奖励3").Trim();
				text = "累计击杀奖励4";
				累计击杀奖励4 = Config.IniReadValue("GameServer", "累计击杀奖励4").Trim();
				text = "抽奖消耗元宝";
				抽奖消耗元宝 = int.Parse(Config.IniReadValue("GameServer", "抽奖消耗元宝").Trim());
				text = "抽奖是否返积分";
				抽奖是否返积分 = int.Parse(Config.IniReadValue("GameServer", "抽奖是否返积分").Trim());
				text = "抽奖返积分比例";
				抽奖返积分比例 = double.Parse(Config.IniReadValue("GameServer", "抽奖返积分比例").Trim());
				text = "全队521开关";
				全队521开关 = int.Parse(Config.IniReadValue("GameServer", "全队521开关").Trim());
				text = "群医范围";
				群医范围 = int.Parse(Config.IniReadValue("GameServer", "群医范围").Trim());
				text = "群医加经验爆率开关";
				群医加经验爆率开关 = int.Parse(Config.IniReadValue("GameServer", "群医加经验爆率开关").Trim());
				text = "群医加爆率百分比";
				群医加爆率百分比 = double.Parse(Config.IniReadValue("GameServer", "群医加爆率百分比").Trim());
				text = "群医加经验百分比";
				群医加经验百分比 = double.Parse(Config.IniReadValue("GameServer", "群医加经验百分比").Trim());
				text = "武器8阶段添加攻击";
				武器8阶段添加攻击 = ((!(Config.IniReadValue("GameServer", "武器8阶段添加攻击").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "武器8阶段添加攻击").Trim()) : 0);
				text = "武器9阶段添加攻击";
				武器9阶段添加攻击 = ((!(Config.IniReadValue("GameServer", "武器9阶段添加攻击").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "武器9阶段添加攻击").Trim()) : 0);
				text = "武器10阶段添加攻击";
				武器10阶段添加攻击 = ((!(Config.IniReadValue("GameServer", "武器10阶段添加攻击").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "武器10阶段添加攻击").Trim()) : 0);
				text = "衣服8阶段添加防御";
				衣服8阶段添加防御 = ((!(Config.IniReadValue("GameServer", "衣服8阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "衣服8阶段添加防御").Trim()) : 0);
				text = "衣服9阶段添加防御";
				衣服9阶段添加防御 = ((!(Config.IniReadValue("GameServer", "衣服9阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "衣服9阶段添加防御").Trim()) : 0);
				text = "衣服10阶段添加防御";
				衣服10阶段添加防御 = ((!(Config.IniReadValue("GameServer", "衣服10阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "衣服10阶段添加防御").Trim()) : 0);
				text = "鞋子8阶段添加防御";
				鞋子8阶段添加防御 = ((!(Config.IniReadValue("GameServer", "鞋子8阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "鞋子8阶段添加防御").Trim()) : 0);
				text = "鞋子9阶段添加防御";
				鞋子9阶段添加防御 = ((!(Config.IniReadValue("GameServer", "鞋子9阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "鞋子9阶段添加防御").Trim()) : 0);
				text = "鞋子10阶段添加防御";
				鞋子10阶段添加防御 = ((!(Config.IniReadValue("GameServer", "鞋子10阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "鞋子10阶段添加防御").Trim()) : 0);
				text = "护手8阶段添加防御";
				护手8阶段添加防御 = ((!(Config.IniReadValue("GameServer", "护手8阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "护手8阶段添加防御").Trim()) : 0);
				text = "护手9阶段添加防御";
				护手9阶段添加防御 = ((!(Config.IniReadValue("GameServer", "护手9阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "护手9阶段添加防御").Trim()) : 0);
				text = "护手10阶段添加防御";
				护手10阶段添加防御 = ((!(Config.IniReadValue("GameServer", "护手10阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "护手10阶段添加防御").Trim()) : 0);
				text = "内甲8阶段添加防御";
				内甲8阶段添加防御 = ((!(Config.IniReadValue("GameServer", "内甲8阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "内甲8阶段添加防御").Trim()) : 0);
				text = "内甲9阶段添加防御";
				内甲9阶段添加防御 = ((!(Config.IniReadValue("GameServer", "内甲9阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "内甲9阶段添加防御").Trim()) : 0);
				text = "内甲10阶段添加防御";
				内甲10阶段添加防御 = ((!(Config.IniReadValue("GameServer", "内甲10阶段添加防御").Trim() == "")) ? int.Parse(Config.IniReadValue("GameServer", "内甲10阶段添加防御").Trim()) : 0);
				text = "版本验证时间";
				版本验证时间 = ((Config.IniReadValue("GameServer", "版本验证时间").Trim() == "") ? 版本验证时间 : int.Parse(Config.IniReadValue("GameServer", "版本验证时间").Trim()));
				text = "创建门派需要等级";
				创建门派需要等级 = ((Config.IniReadValue("GameServer", "创建门派需要等级").Trim() == "") ? 创建门派需要等级 : int.Parse(Config.IniReadValue("GameServer", "创建门派需要等级").Trim()));
				text = "创建门派所需物品ID";
				创建门派所需物品ID = ((Config.IniReadValue("GameServer", "创建门派所需物品ID").Trim() == "") ? 创建门派所需物品ID : Config.IniReadValue("GameServer", "创建门派所需物品ID").Trim());
				text = "安全区开关";
				安全区开关 = ((Config.IniReadValue("GameServer", "安全区开关").Trim() == "") ? 安全区开关 : int.Parse(Config.IniReadValue("GameServer", "安全区开关").Trim()));
				text = "查非法物品";
				查非法物品 = ((Config.IniReadValue("GameServer", "查非法物品").Trim() == "") ? 查非法物品 : int.Parse(Config.IniReadValue("GameServer", "查非法物品").Trim()));
				text = "查绑定非法物品";
				查绑定非法物品 = ((Config.IniReadValue("GameServer", "查绑定非法物品").Trim() == "") ? 查绑定非法物品 : (Config.IniReadValue("GameServer", "查绑定非法物品").Trim() == "1"));
				text = "查非法物品操作";
				查非法物品操作 = ((Config.IniReadValue("GameServer", "查非法物品操作").Trim() == "") ? 查非法物品操作 : int.Parse(Config.IniReadValue("GameServer", "查非法物品操作").Trim()));
				text = "物品最高攻击值";
				物品最高攻击值 = ((Config.IniReadValue("GameServer", "物品最高攻击值").Trim() == "") ? 物品最高攻击值 : int.Parse(Config.IniReadValue("GameServer", "物品最高攻击值").Trim()));
				text = "物品最高防御值";
				物品最高防御值 = ((Config.IniReadValue("GameServer", "物品最高防御值").Trim() == "") ? 物品最高防御值 : int.Parse(Config.IniReadValue("GameServer", "物品最高防御值").Trim()));
				text = "物品最高武功值";
				物品最高武功值 = ((Config.IniReadValue("GameServer", "物品最高武功值").Trim() == "") ? 物品最高武功值 : int.Parse(Config.IniReadValue("GameServer", "物品最高武功值").Trim()));
				text = "物品最高武防值";
				物品最高武防值 = ((Config.IniReadValue("GameServer", "物品最高武防值").Trim() == "") ? 物品最高武防值 : int.Parse(Config.IniReadValue("GameServer", "物品最高武防值").Trim()));
				text = "SqlJl";
				SqlJl = ((Config.IniReadValue("GameServer", "SqlJl").Trim() == "") ? SqlJl : Config.IniReadValue("GameServer", "SqlJl").Trim());
				text = "自动存档";
				自动存档 = ((Config.IniReadValue("GameServer", "自动存档").Trim() == "") ? 自动存档 : int.Parse(Config.IniReadValue("GameServer", "自动存档").Trim()));
				text = "PK记录";
				PK记录 = ((Config.IniReadValue("GameServer", "PK记录").Trim() == "") ? PK记录 : int.Parse(Config.IniReadValue("GameServer", "PK记录").Trim()));
				text = "物品记录";
				物品记录 = ((Config.IniReadValue("GameServer", "物品记录").Trim() == "") ? 物品记录 : int.Parse(Config.IniReadValue("GameServer", "物品记录").Trim()));
				text = "登陆记录";
				登陆记录 = ((Config.IniReadValue("GameServer", "登陆记录").Trim() == "") ? 登陆记录 : int.Parse(Config.IniReadValue("GameServer", "登陆记录").Trim()));
				text = "记录保存天数";
				记录保存天数 = ((Config.IniReadValue("GameServer", "记录保存天数").Trim() == "") ? 记录保存天数 : int.Parse(Config.IniReadValue("GameServer", "记录保存天数").Trim()));
				text = "元宝合成";
				元宝合成 = ((Config.IniReadValue("GameServer", "元宝合成需要元宝").Trim() == "") ? 元宝合成 : int.Parse(Config.IniReadValue("GameServer", "元宝合成需要元宝").Trim()));
				text = "复制物品是否封号";
				复制物品是否封号 = ((Config.IniReadValue("GameServer", "复制物品是否封号").Trim() == "") ? 复制物品是否封号 : int.Parse(Config.IniReadValue("GameServer", "复制物品是否封号").Trim()));
				text = "复制物品检查时间";
				复制物品检查时间 = ((Config.IniReadValue("GameServer", "复制物品检查时间").Trim() == "") ? 复制物品检查时间 : int.Parse(Config.IniReadValue("GameServer", "复制物品检查时间").Trim()));
				text = "新人保护等级";
				新人保护等级 = ((Config.IniReadValue("GameServer", "新人保护等级").Trim() == "") ? 新人保护等级 : int.Parse(Config.IniReadValue("GameServer", "新人保护等级").Trim()));
				text = "不受保护符地图";
				string text3 = (Config.IniReadValue("GameServer", "不受保护符地图").Trim() == "") ? "" : Config.IniReadValue("GameServer", "不受保护符地图").Trim();
				if (!string.IsNullOrEmpty(text3))
				{
					不受保护符地图 = (from i in text3.Split(',')
						select int.Parse(i)).ToList();
				}
				text = "组队级别限制";
				组队级别限制 = ((Config.IniReadValue("GameServer", "组队级别限制").Trim() == "") ? 组队级别限制 : int.Parse(Config.IniReadValue("GameServer", "组队级别限制").Trim()));
				text = "PK等级差";
				PK等级差 = ((Config.IniReadValue("GameServer", "PK等级差").Trim() == "") ? PK等级差 : int.Parse(Config.IniReadValue("GameServer", "PK等级差").Trim()));
				text = "人物最高等级";
				人物最高等级 = ((Config.IniReadValue("GameServer", "人物最高等级").Trim() == "") ? 人物最高等级 : int.Parse(Config.IniReadValue("GameServer", "人物最高等级").Trim()));
				text = "经验珠最高等级";
				人物最高等级 = ((Config.IniReadValue("GameServer", "经验珠最高等级").Trim() == "") ? 人物最高等级 : int.Parse(Config.IniReadValue("GameServer", "经验珠最高等级").Trim()));
				text = "封印等级";
				封印等级 = ((Config.IniReadValue("GameServer", "封印等级").Trim() == "") ? 封印等级 : int.Parse(Config.IniReadValue("GameServer", "封印等级").Trim()));
				text = "武功攻击力控制";
				武功攻击力控制 = ((Config.IniReadValue("GameServer", "武功攻击力控制").Trim() == "") ? 武功攻击力控制 : double.Parse(Config.IniReadValue("GameServer", "武功攻击力控制").Trim()));
				text = "武功防御力控制";
				武功防御力控制 = ((Config.IniReadValue("GameServer", "武功攻击力控制").Trim() == "") ? 武功防御力控制 : ((double)int.Parse(Config.IniReadValue("GameServer", "武功防御力控制").Trim())));
				text = "装备加解锁开关";
				装备加解锁开关 = ((Config.IniReadValue("GameServer", "装备加解锁开关").Trim() == "") ? 装备加解锁开关 : int.Parse(Config.IniReadValue("GameServer", "装备加解锁开关").Trim()));
				text = "加锁元宝数";
				加锁元宝数 = ((Config.IniReadValue("GameServer", "加锁元宝数").Trim() == "") ? 加锁元宝数 : int.Parse(Config.IniReadValue("GameServer", "加锁元宝数").Trim()));
				text = "解锁元宝数";
				解锁元宝数 = ((Config.IniReadValue("GameServer", "解锁元宝数").Trim() == "") ? 解锁元宝数 : int.Parse(Config.IniReadValue("GameServer", "解锁元宝数").Trim()));
				text = "加锁金币数";
				加锁金币数 = ((Config.IniReadValue("GameServer", "加锁金币数").Trim() == "") ? 加锁金币数 : int.Parse(Config.IniReadValue("GameServer", "加锁金币数").Trim()));
				text = "解锁金币数";
				解锁金币数 = ((Config.IniReadValue("GameServer", "解锁金币数").Trim() == "") ? 解锁金币数 : int.Parse(Config.IniReadValue("GameServer", "解锁金币数").Trim()));
				text = "强化公告等级";
				强化公告等级 = ((Config.IniReadValue("GameServer", "强化公告等级").Trim() == "") ? 强化公告等级 : int.Parse(Config.IniReadValue("GameServer", "强化公告等级").Trim()));
				text = "武勋保护药品";
				武勋保护药品 = ((Config.IniReadValue("GameServer", "武勋保护药品ID").Trim() == "") ? 武勋保护药品 : int.Parse(Config.IniReadValue("GameServer", "武勋保护药品ID").Trim()));
				text = "武勋解保护药品";
				武勋解保护药品 = ((Config.IniReadValue("GameServer", "武勋解保护药品ID").Trim() == "") ? 武勋解保护药品 : int.Parse(Config.IniReadValue("GameServer", "武勋解保护药品ID").Trim()));
				text = "扔物品操作";
				扔物品操作 = ((Config.IniReadValue("GameServer", "扔物品操作").Trim() == "") ? 扔物品操作 : int.Parse(Config.IniReadValue("GameServer", "扔物品操作").Trim()));
				text = "医生弓手攻击距离";
				医生弓手攻击距离 = ((Config.IniReadValue("GameServer", "医生弓手攻击可视距离").Trim() == "") ? 医生弓手攻击距离 : int.Parse(Config.IniReadValue("GameServer", "医生弓手攻击可视距离").Trim()));
				text = "刀枪剑攻击距离";
				刀枪剑攻击距离 = ((Config.IniReadValue("GameServer", "刀枪剑攻击可视距离").Trim() == "") ? 刀枪剑攻击距离 : int.Parse(Config.IniReadValue("GameServer", "刀枪剑攻击可视距离").Trim()));
				text = "是否开启死亡掉经验";
				是否开启死亡掉经验 = ((Config.IniReadValue("GameServer", "是否开启死亡掉经验").Trim() == "") ? 是否开启死亡掉经验 : int.Parse(Config.IniReadValue("GameServer", "是否开启死亡掉经验").Trim()));
				text = "死亡掉经验开始等级";
				死亡掉经验开始等级 = ((Config.IniReadValue("GameServer", "死亡掉经验开始等级").Trim() == "") ? 死亡掉经验开始等级 : int.Parse(Config.IniReadValue("GameServer", "死亡掉经验开始等级").Trim()));
				text = "死亡掉经验比例";
				死亡掉经验比例 = ((Config.IniReadValue("GameServer", "死亡掉经验比例").Trim() == "") ? 死亡掉经验比例 : int.Parse(Config.IniReadValue("GameServer", "死亡掉经验比例").Trim()));
				text = "死亡复活锁定时间";
				死亡复活锁定时间 = ((Config.IniReadValue("GameServer", "死亡复活锁定时间").Trim() == "") ? 死亡复活锁定时间 : int.Parse(Config.IniReadValue("GameServer", "死亡复活锁定时间").Trim()));
				text = "是否开启师徒系统";
				是否开启师徒系统 = ((Config.IniReadValue("GameServer", "是否开启师徒系统").Trim() == "") ? 是否开启师徒系统 : int.Parse(Config.IniReadValue("GameServer", "是否开启师徒系统").Trim()));
				text = "徒弟最高等级限制";
				徒弟最高等级限制 = ((Config.IniReadValue("GameServer", "徒弟最高等级限制").Trim() == "") ? 徒弟最高等级限制 : int.Parse(Config.IniReadValue("GameServer", "徒弟最高等级限制").Trim()));
				text = "再造系统是否开启";
				再造系统是否开启 = ((Config.IniReadValue("GameServer", "再造系统是否开启").Trim() == "") ? 再造系统是否开启 : int.Parse(Config.IniReadValue("GameServer", "再造系统是否开启").Trim()));
				text = "BOSS权限需要积分";
				BOSS权限需要积分 = ((Config.IniReadValue("GameServer", "BOSS权限需要积分").Trim() == "") ? BOSS权限需要积分 : int.Parse(Config.IniReadValue("GameServer", "BOSS权限需要积分").Trim()));
				text = "BOSS初始化次数";
				BOSS初始化次数 = ((Config.IniReadValue("GameServer", "BOSS初始化次数").Trim() == "") ? BOSS初始化次数 : int.Parse(Config.IniReadValue("GameServer", "BOSS初始化次数").Trim()));
				text = "BOSS金符持有初始化次数";
				BOSS金符持有初始化次数 = ((Config.IniReadValue("GameServer", "BOSS金符持有初始化次数").Trim() == "") ? BOSS金符持有初始化次数 : int.Parse(Config.IniReadValue("GameServer", "BOSS金符持有初始化次数").Trim()));
				text = "是否开启查看装备功能";
				是否开启查看装备功能 = ((Config.IniReadValue("GameServer", "是否开启查看装备功能").Trim() == "") ? 是否开启查看装备功能 : int.Parse(Config.IniReadValue("GameServer", "是否开启查看装备功能").Trim()));
				text = "最大钱数";
				最大钱数 = ((Config.IniReadValue("GameServer", "限制玩家最大金币数").Trim() == "") ? 最大钱数 : int.Parse(Config.IniReadValue("GameServer", "限制玩家最大金币数").Trim()));
				text = "最大元宝数";
				最大元宝数 = ((Config.IniReadValue("GameServer", "限制玩家最大元宝数").Trim() == "") ? 最大元宝数 : int.Parse(Config.IniReadValue("GameServer", "限制玩家最大元宝数").Trim()));
				text = "是否开启跨线传音";
				是否开启跨线传音 = ((Config.IniReadValue("GameServer", "是否开启跨线传音").Trim() == "") ? 是否开启跨线传音 : int.Parse(Config.IniReadValue("GameServer", "是否开启跨线传音").Trim()));
				text = "窗口名检测模式";
				窗口名检测模式 = ((Config.IniReadValue("GameServer", "窗口名检测模式").Trim() == "") ? 窗口名检测模式 : int.Parse(Config.IniReadValue("GameServer", "窗口名检测模式").Trim()));
				text = "安全码开关";
				安全码开关 = int.Parse(Config.IniReadValue("GameServer", "安全码开关").Trim());
				text = "开启命令换线";
				开启命令换线 = int.Parse(Config.IniReadValue("GameServer", "开启命令换线").Trim());
				text = "开启NPC换线";
				开启NPC换线 = int.Parse(Config.IniReadValue("GameServer", "开启NPC换线").Trim());
				text = "泫勃派回城符永久使用";
				泫勃派回城符永久使用 = int.Parse(Config.IniReadValue("GameServer", "泫勃派回城符永久使用").Trim());
				text = "回城符单次扣除金币";
				回城符单次扣除金币 = int.Parse(Config.IniReadValue("GameServer", "回城符单次扣除金币").Trim());
				text = "限制武勋地图";
				限制武勋地图 = Config.IniReadValue("GameServer", "限制武勋地图").Trim();
				text = "限制武勋地图数量";
				限制武勋地图数量 = int.Parse(Config.IniReadValue("GameServer", "限制武勋地图数量").Trim());
				int num2 = 0;
				text = "地图锁定";
				try
				{
					地图锁定 = Config.IniReadValue("GameServer", "地图锁定").Trim();
					Config.IniReadValue("GameServer", "帮派混战胜利奖励");
					Config.IniReadValue("GameServer", "帮派混战失败奖励");
					for (int l = 0; l < 5; l++)
					{
					}
					text = "金符地图";
					金符地图 = Config.IniReadValue("GameServer", "金符地图").Trim();
				}
				catch (Exception ex3)
				{
					Form1.WriteLine(1, "配置文件加载势力战奖励，帮派混战战奖励错误:" + ex3.Message);
				}
				try
				{
					text = "限制PK地图";
					string text4 = (Config.IniReadValue("GameServer", "限制PK地图").Trim() == "") ? "" : Config.IniReadValue("GameServer", "限制PK地图").Trim();
					限制PK地图列表.Clear();
					if (text4 != "")
					{
						num2 = 1;
						string[] array3 = text4.Split(';');
						string[] array4 = array3;
						string[] array5 = array4;
						string[] array6 = array5;
						string[] array7 = array6;
						string[] array8 = array7;
						string[] array9 = array8;
						string[] array10 = array9;
						string[] array11 = array10;
						foreach (string s in array11)
						{
							if (!限制PK地图列表.Contains(int.Parse(s)))
							{
								限制PK地图列表.Add(int.Parse(s));
							}
						}
						num2 = 2;
					}
					text = "限时间PK地图";
					string text5 = (Config.IniReadValue("GameServer", "限时间PK地图").Trim() == "") ? "" : Config.IniReadValue("GameServer", "限时间PK地图").Trim();
					限时PK地图列表.Clear();
					if (text5 != "")
					{
						num2 = 3;
						string[] array12 = text5.Split(';');
						string[] array13 = array12;
						string[] array14 = array13;
						string[] array15 = array14;
						string[] array16 = array15;
						string[] array17 = array16;
						string[] array18 = array17;
						string[] array19 = array18;
						string[] array20 = array19;
						foreach (string s2 in array20)
						{
							if (!限时PK地图列表.Contains(int.Parse(s2)))
							{
								限时PK地图列表.Add(int.Parse(s2));
							}
						}
						num2 = 4;
					}
					text = "限时地图开PK时间";
					限时地图开PK时间 = ((Config.IniReadValue("GameServer", "限时地图开PK时间").Trim() == "") ? 限时地图开PK时间 : int.Parse(Config.IniReadValue("GameServer", "限时地图开PK时间").Trim()));
					text = "工作日限时地图开PK时间";
					工作日限时地图开PK时间 = ((Config.IniReadValue("GameServer", "工作日限时地图开PK时间").Trim() == "") ? 工作日限时地图开PK时间 : int.Parse(Config.IniReadValue("GameServer", "工作日限时地图开PK时间").Trim()));
					text = "限时地图关PK时间";
					限时地图关PK时间 = ((Config.IniReadValue("GameServer", "限时地图关PK时间").Trim() == "") ? 限时地图关PK时间 : int.Parse(Config.IniReadValue("GameServer", "限时地图关PK时间").Trim()));
					text = "工作日限时地图关PK时间";
					工作日限时地图关PK时间 = ((Config.IniReadValue("GameServer", "工作日限时地图关PK时间").Trim() == "") ? 工作日限时地图关PK时间 : int.Parse(Config.IniReadValue("GameServer", "工作日限时地图关PK时间").Trim()));
					text = "周末全天PK是否开启";
					周末全天PK是否开启 = ((Config.IniReadValue("GameServer", "周末全天PK是否开启").Trim() == "") ? 周末全天PK是否开启 : int.Parse(Config.IniReadValue("GameServer", "周末全天PK是否开启").Trim()));
					text = "全天PK地图";
					string text6 = (Config.IniReadValue("GameServer", "全天PK地图").Trim() == "") ? "1301;2001;5001" : Config.IniReadValue("GameServer", "全天PK地图").Trim();
					周末全天PK地图列表.Clear();
					num2 = 5;
					if (text6 != "")
					{
						num2 = 6;
						string[] array21 = text6.Split(';');
						string[] array22 = array21;
						string[] array23 = array22;
						string[] array24 = array23;
						string[] array25 = array24;
						string[] array26 = array25;
						string[] array27 = array26;
						string[] array28 = array27;
						string[] array29 = array28;
						foreach (string s3 in array29)
						{
							if (!周末全天PK地图列表.Contains(int.Parse(s3)))
							{
								周末全天PK地图列表.Add(int.Parse(s3));
							}
						}
						num2 = 7;
					}
					text = "物品锁定";
					string text7 = Config.IniReadValue("GameServer", "物品锁定").Trim();
					锁定物品列表.Clear();
					num2 = 8;
					if (text7 != "")
					{
						num2 = 9;
						string[] array30 = text7.Split(',');
						string[] array31 = array30;
						string[] array32 = array31;
						string[] array33 = array32;
						string[] array34 = array33;
						string[] array35 = array34;
						string[] array36 = array35;
						string[] array37 = array36;
						string[] array38 = array37;
						foreach (string s4 in array38)
						{
							if (!锁定物品列表.Contains(int.Parse(s4)))
							{
								锁定物品列表.Add(int.Parse(s4));
							}
						}
						num2 = 10;
					}
					text = "查复制全局ID";
					string text8 = (Config.IniReadValue("GameServer", "查复制全局ID").Trim() == "") ? "" : Config.IniReadValue("GameServer", "查复制全局ID").Trim();
					查复制物品列表.Clear();
					num2 = 11;
					if (text8 != "")
					{
						num2 = 12;
						string[] array39 = text8.Split(',');
						string[] array40 = array39;
						string[] array41 = array40;
						string[] array42 = array41;
						string[] array43 = array42;
						string[] array44 = array43;
						string[] array45 = array44;
						string[] array46 = array45;
						string[] array47 = array46;
						foreach (string s5 in array47)
						{
							if (!查复制物品列表.Contains(long.Parse(s5)))
							{
								查复制物品列表.Add(long.Parse(s5));
							}
						}
						num2 = 13;
					}
					string text9 = (Config.IniReadValue("GameServer", "需要任务等级列表").Trim() == "") ? "" : Config.IniReadValue("GameServer", "需要任务等级列表").Trim();
					lockLevel.Clear();
					num2 = 18;
					if (text9 != "")
					{
						string[] array48 = text9.Split(';');
						for (int num6 = 0; num6 < array48.Length; num6++)
						{
							int item = int.Parse(array48[num6]);
							lockLevel.Add(item);
						}
						num2 = 19;
					}
					text = "寄售系统是否开启";
					寄售系统是否开启 = ((Config.IniReadValue("GameServer", "寄售系统是否开启").Trim() == "") ? 寄售系统是否开启 : int.Parse(Config.IniReadValue("GameServer", "寄售系统是否开启").Trim()));
					text = "寄售获得元宝比例";
					寄售获得元宝比例 = ((Config.IniReadValue("GameServer", "寄售获得元宝比例").Trim() == "") ? 寄售获得元宝比例 : double.Parse(Config.IniReadValue("GameServer", "寄售获得元宝比例").Trim()));
					text = "是否可以寄售绑定装备";
					是否可以寄售绑定装备 = ((Config.IniReadValue("GameServer", "是否可以寄售绑定装备").Trim() == "") ? 是否可以寄售绑定装备 : int.Parse(Config.IniReadValue("GameServer", "是否可以寄售绑定装备").Trim()));
					text = "允许交易等级";
					允许交易等级 = ((Config.IniReadValue("GameServer", "允许交易等级").Trim() == "") ? 允许交易等级 : int.Parse(Config.IniReadValue("GameServer", "允许交易等级").Trim()));
					text = "允许交易披风";
					允许交易披风 = ((Config.IniReadValue("GameServer", "允许交易披风").Trim() == "") ? 允许交易披风 : int.Parse(Config.IniReadValue("GameServer", "允许交易披风").Trim()));
					text = "是否允许开店";
					是否允许开店 = ((Config.IniReadValue("GameServer", "是否允许开店").Trim() == "") ? 是否允许开店 : int.Parse(Config.IniReadValue("GameServer", "是否允许开店").Trim()));
					text = "百宝物品禁止卖店";
					百宝物品禁止卖店 = int.Parse(Config.IniReadValue("GameServer", "百宝物品禁止卖店").Trim());
					text = "自动打开武勋状态";
					自动打开武勋状态 = int.Parse(Config.IniReadValue("GameServer", "自动打开武勋状态").Trim());
					text = "自动组队功能开关";
					自动组队功能开关 = int.Parse(Config.IniReadValue("GameServer", "自动组队功能开关").Trim());
					text = "BOOS总开关";
					BOOS总开关 = int.Parse(Config.IniReadValue("GameServer", "BOOS总开关").Trim());
					text = "BOSSPID";
					BOSSPID = int.Parse(Config.IniReadValue("GameServer", "BOSSPID").Trim());
					text = "BOSS的地图";
					BOSS的地图 = int.Parse(Config.IniReadValue("GameServer", "BOSS地图").Trim());
					text = "BOSS坐标X";
					BOSS坐标X = int.Parse(Config.IniReadValue("GameServer", "BOSS坐标X").Trim());
					text = "BOSS坐标Y";
					BOSS坐标Y = int.Parse(Config.IniReadValue("GameServer", "BOSS坐标Y").Trim());
					text = "BOSS开启小时";
					BOSS开启小时 = int.Parse(Config.IniReadValue("GameServer", "BOSS开启小时").Trim());
					text = "BOSS开启分钟";
					BOSS开启分钟 = int.Parse(Config.IniReadValue("GameServer", "BOSS开启分钟").Trim());
					text = "BOSS开启秒";
					BOSS开启秒 = int.Parse(Config.IniReadValue("GameServer", "BOSS开启秒").Trim());
					text = "BOSS存活秒";
					BOSS存活秒 = int.Parse(Config.IniReadValue("GameServer", "BOSS存活秒").Trim());
					text = "BOSS第1名奖励物品ID";
					BOSS第1名奖励物品ID = int.Parse(Config.IniReadValue("GameServer", "BOSS第1名奖励物品ID").Trim());
					text = "BOSS第1名奖励物品ID2";
					BOSS第1名奖励物品ID2 = int.Parse(Config.IniReadValue("GameServer", "BOSS第1名奖励物品ID2").Trim());
					text = "BOSS第2名奖励物品ID";
					BOSS第2名奖励物品ID = int.Parse(Config.IniReadValue("GameServer", "BOSS第2名奖励物品ID").Trim());
					text = "BOSS第2名奖励物品ID2";
					BOSS第2名奖励物品ID2 = int.Parse(Config.IniReadValue("GameServer", "BOSS第2名奖励物品ID2").Trim());
					text = "BOSS第3名奖励物品ID";
					BOSS第3名奖励物品ID = int.Parse(Config.IniReadValue("GameServer", "BOSS第3名奖励物品ID").Trim());
					text = "BOSS第3名奖励物品ID2";
					BOSS第3名奖励物品ID2 = int.Parse(Config.IniReadValue("GameServer", "BOSS第3名奖励物品ID2").Trim());
					text = "BOSS4-10名奖励物品ID";
					BOSS410名奖励物品ID = int.Parse(Config.IniReadValue("GameServer", "BOSS4-10名奖励物品ID").Trim());
					text = "BOSS11-20名奖励物品ID";
					BOSS1120名奖励物品ID = int.Parse(Config.IniReadValue("GameServer", "BOSS11-20名奖励物品ID").Trim());
					text = "世界BOSS掉落元宝最小";
					世界BOSS掉落元宝最小 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落元宝最小").Trim());
					text = "世界BOSS掉落元宝最大";
					世界BOSS掉落元宝最大 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落元宝最大").Trim());
					text = "世界BOSS元宝爆率";
					世界BOSS元宝爆率 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS元宝爆率").Trim());
					text = "世界BOSS掉落武勋最小";
					世界BOSS掉落武勋最小 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落武勋最小").Trim());
					text = "世界BOSS掉落武勋最大";
					世界BOSS掉落武勋最大 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落武勋最大").Trim());
					text = "世界BOSS掉落金币最小";
					世界BOSS掉落金币最小 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落金币最小").Trim());
					text = "世界BOSS掉落金币最大";
					世界BOSS掉落金币最大 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS掉落金币最大").Trim());
					text = "世界BOSS武勋爆率";
					世界BOSS武勋爆率 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS武勋爆率").Trim());
					text = "世界BOSS物品爆率";
					世界BOSS物品爆率 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS物品爆率").Trim());
					text = "世界BOSS爆物品";
					世界BOSS爆物品 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS爆物品").Trim());
					text = "世界BOSS金币爆率";
					世界BOSS金币爆率 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS金币爆率").Trim());
					text = "世界BOSS最后一击奖励元宝";
					世界BOSS最后一击奖励元宝 = int.Parse(Config.IniReadValue("GameServer", "世界BOSS最后一击奖励元宝").Trim());
					text = "BOSS血";
					BOSS血 = int.Parse(Config.IniReadValue("GameServer", "BOSS血").Trim());
					text = "BOSS攻击";
					BOSS攻击 = int.Parse(Config.IniReadValue("GameServer", "BOSS攻击").Trim());
					text = "BOSS防御";
					BOSS防御 = int.Parse(Config.IniReadValue("GameServer", "BOSS防御").Trim());
					text = "BOSS开启公告";
					BOSS开启公告 = Config.IniReadValue("GameServer", "BOSS开启公告").Trim();
					text = "BOSS结束公告";
					BOSS结束公告 = Config.IniReadValue("GameServer", "BOSS结束公告").Trim();
					text = "BOSS开启命令";
					BOSS开启命令 = Config.IniReadValue("GameServer", "BOSS开启命令").Trim();
					num2 = 20;
				}
				catch (Exception ex4)
				{
					Form1.WriteLine(1, num2.ToString() + " 配置文件加载挂机地图表错误:[错误位置:" + text + "]" + ex4.Message);
				}
			}
			catch (Exception ex5)
			{
				Form1.WriteLine(1, "游戏相关配置.ini 配置错误,请询问QQ593323947仔细查看更新文件:[错误位置:" + text + "]" + ex5.Message);
			}
		}

		public void SetqgConfig()
		{
			string str = "";
			try
			{
				str = "气功相关配置.ini";
				Config.Pathqg = Application.StartupPath + "\\气功相关配置.ini";
				str = "弓箭平A伤害";
				弓箭平A伤害 = double.Parse(Config.IniReadValuee("气功配置", "弓箭平A伤害").Trim());
				str = "刀力劈华山";
				刀力劈华山 = double.Parse(Config.IniReadValuee("气功配置", "刀力劈华山").Trim());
				str = "刀摄魂一击";
				刀摄魂一击 = double.Parse(Config.IniReadValuee("气功配置", "刀摄魂一击").Trim());
				str = "刀连环飞舞概率";
				刀连环飞舞概率 = double.Parse(Config.IniReadValuee("气功配置", "刀连环飞舞概率").Trim());
				str = "刀必杀一击概率";
				刀必杀一击概率 = double.Parse(Config.IniReadValuee("气功配置", "刀必杀一击概率").Trim());
				str = "刀四两千金概率";
				刀四两千金概率 = double.Parse(Config.IniReadValuee("气功配置", "刀四两千金概率").Trim());
				str = "刀霸气破甲概率";
				刀霸气破甲概率 = double.Parse(Config.IniReadValuee("气功配置", "刀霸气破甲概率").Trim());
				str = "刀霸气破甲效果";
				刀霸气破甲效果 = double.Parse(Config.IniReadValuee("气功配置", "刀霸气破甲效果").Trim());
				str = "刀真武绝技概率";
				刀真武绝技概率 = double.Parse(Config.IniReadValuee("气功配置", "刀真武绝技概率").Trim());
				str = "刀真武绝技伤害";
				刀真武绝技伤害 = double.Parse(Config.IniReadValuee("气功配置", "刀真武绝技伤害").Trim());
				str = "刀暗影绝杀概率";
				刀暗影绝杀概率 = double.Parse(Config.IniReadValuee("气功配置", "刀暗影绝杀概率").Trim());
				str = "刀暗影绝杀伤害";
				刀暗影绝杀伤害 = double.Parse(Config.IniReadValuee("气功配置", "刀暗影绝杀伤害").Trim());
				str = "刀流光万舞伤害";
				刀流光万舞伤害 = double.Parse(Config.IniReadValuee("气功配置", "刀流光万舞伤害").Trim());
				str = "剑长虹贯日攻击";
				剑长虹贯日攻击 = double.Parse(Config.IniReadValuee("气功配置", "剑长虹贯日攻击").Trim());
				str = "剑移花接木概率";
				剑移花接木概率 = double.Parse(Config.IniReadValuee("气功配置", "剑移花接木概率").Trim());
				str = "剑百变神行概率";
				剑百变神行概率 = double.Parse(Config.IniReadValuee("气功配置", "剑百变神行概率").Trim());
				str = "剑连环飞舞概率";
				剑连环飞舞概率 = double.Parse(Config.IniReadValuee("气功配置", "剑连环飞舞概率").Trim());
				str = "剑必杀一击概率";
				剑必杀一击概率 = double.Parse(Config.IniReadValuee("气功配置", "剑必杀一击概率").Trim());
				str = "剑护身罡气概率";
				剑护身罡气概率 = double.Parse(Config.IniReadValuee("气功配置", "剑护身罡气概率").Trim());
				str = "剑回柳身法武功";
				剑回柳身法武功 = double.Parse(Config.IniReadValuee("气功配置", "剑回柳身法武功").Trim());
				str = "剑回柳身法概率";
				剑回柳身法概率 = double.Parse(Config.IniReadValuee("气功配置", "剑回柳身法概率").Trim());
				str = "剑怒海狂澜概率";
				剑怒海狂澜概率 = double.Parse(Config.IniReadValuee("气功配置", "剑怒海狂澜概率").Trim());
				str = "剑冲冠一怒概率";
				剑冲冠一怒概率 = double.Parse(Config.IniReadValuee("气功配置", "剑冲冠一怒概率").Trim());
				str = "剑无坚不摧概率";
				剑无坚不摧概率 = double.Parse(Config.IniReadValuee("气功配置", "剑无坚不摧概率").Trim());
				str = "剑无坚不摧效果";
				剑无坚不摧效果 = double.Parse(Config.IniReadValuee("气功配置", "剑无坚不摧效果").Trim());
				str = "枪连环飞舞概率";
				枪连环飞舞概率 = double.Parse(Config.IniReadValuee("气功配置", "枪连环飞舞概率").Trim());
				str = "枪必杀一击概率";
				枪必杀一击概率 = double.Parse(Config.IniReadValuee("气功配置", "枪必杀一击概率").Trim());
				str = "枪金钟罡气";
				枪金钟罡气 = double.Parse(Config.IniReadValuee("气功配置", "枪金钟罡气").Trim());
				str = "枪运气疗伤";
				枪运气疗伤 = double.Parse(Config.IniReadValuee("气功配置", "枪运气疗伤").Trim());
				str = "枪横练太保";
				枪横练太保 = double.Parse(Config.IniReadValuee("气功配置", "枪横练太保").Trim());
				str = "枪乾坤挪移";
				枪乾坤挪移 = double.Parse(Config.IniReadValuee("气功配置", "枪乾坤挪移").Trim());
				str = "枪狂神降世";
				枪狂神降世 = double.Parse(Config.IniReadValuee("气功配置", "枪狂神降世").Trim());
				str = "枪转攻为守";
				枪转攻为守 = double.Parse(Config.IniReadValuee("气功配置", "枪转攻为守").Trim());
				str = "枪末日狂舞";
				枪末日狂舞 = double.Parse(Config.IniReadValuee("气功配置", "枪末日狂舞").Trim());
				str = "枪灵甲护身";
				枪灵甲护身 = double.Parse(Config.IniReadValuee("气功配置", "枪灵甲护身").Trim());
				str = "弓必杀一击概率";
				弓必杀一击概率 = double.Parse(Config.IniReadValuee("气功配置", "弓必杀一击概率").Trim());
				str = "弓百步穿杨";
				弓百步穿杨 = double.Parse(Config.IniReadValuee("气功配置", "弓百步穿杨").Trim());
				str = "弓凝神聚气";
				弓凝神聚气 = double.Parse(Config.IniReadValuee("气功配置", "弓凝神聚气").Trim());
				str = "弓心神凝聚概率";
				弓心神凝聚概率 = double.Parse(Config.IniReadValuee("气功配置", "弓心神凝聚概率").Trim());
				str = "弓心神凝聚伤害";
				弓心神凝聚伤害 = double.Parse(Config.IniReadValuee("气功配置", "弓心神凝聚伤害").Trim());
				str = "弓流星三矢概率";
				弓流星三矢概率 = double.Parse(Config.IniReadValuee("气功配置", "弓流星三矢概率").Trim());
				str = "弓锐利之箭";
				弓锐利之箭 = double.Parse(Config.IniReadValuee("气功配置", "弓锐利之箭").Trim());
				str = "弓无明暗矢概率";
				弓无明暗矢概率 = double.Parse(Config.IniReadValuee("气功配置", "弓无明暗矢概率").Trim());
				str = "弓致命绝杀概率";
				弓致命绝杀概率 = double.Parse(Config.IniReadValuee("气功配置", "弓致命绝杀概率").Trim());
				str = "弓致命绝杀伤害";
				弓致命绝杀伤害 = double.Parse(Config.IniReadValuee("气功配置", "弓致命绝杀伤害").Trim());
				str = "医运气行心";
				医运气行心 = double.Parse(Config.IniReadValuee("气功配置", "医运气行心").Trim());
				str = "体血倍增";
				体血倍增 = double.Parse(Config.IniReadValuee("气功配置", "体血倍增").Trim());
				str = "洗髓易筋";
				洗髓易筋 = double.Parse(Config.IniReadValuee("气功配置", "洗髓易筋").Trim());
				str = "医长攻击力";
				医长攻击力 = double.Parse(Config.IniReadValuee("气功配置", "医长攻击力").Trim());
				str = "医吸星大法";
				医吸星大法 = double.Parse(Config.IniReadValuee("气功配置", "医吸星大法").Trim());
				str = "医天佑之气";
				医天佑之气 = double.Parse(Config.IniReadValuee("气功配置", "医天佑之气").Trim());
				str = "医九天真气";
				医九天真气 = double.Parse(Config.IniReadValuee("气功配置", "医九天真气").Trim());
				str = "医万物回春";
				医万物回春 = double.Parse(Config.IniReadValuee("气功配置", "医万物回春").Trim());
				str = "是否开启气功提示";
				是否开启气功提示 = ((Config.IniReadValuee("气功配置", "是否开启气功提示").Trim() == "") ? 是否开启气功提示 : int.Parse(Config.IniReadValuee("气功配置", "是否开启气功提示").Trim()));
				str = "气功百分比";
				气功百分比 = ((Config.IniReadValuee("气功配置", "气功百分比").Trim() == "") ? 气功百分比 : double.Parse(Config.IniReadValuee("气功配置", "气功百分比").Trim()));
				str = "最大气功数";
				最大气功数 = ((Config.IniReadValuee("气功配置", "最大气功数").Trim() == "") ? 最大气功数 : int.Parse(Config.IniReadValuee("气功配置", "最大气功数").Trim()));
				str = "医生回气疗伤加血量";
				医生回气疗伤加血量 = int.Parse(Config.IniReadValuee("气功配置", "医生回气疗伤加血量").Trim());
				str = "医生运气疗伤加血量";
				医生运气疗伤加血量 = int.Parse(Config.IniReadValuee("气功配置", "医生运气疗伤加血量").Trim());
				str = "医生聚气疗伤加血量";
				医生聚气疗伤加血量 = int.Parse(Config.IniReadValuee("气功配置", "医生聚气疗伤加血量").Trim());
				str = "气功是否有效";
				气功是否有效 = ((Config.IniReadValuee("气功配置", "气功是否有效").Trim() == "") ? 气功是否有效 : int.Parse(Config.IniReadValuee("气功配置", "气功是否有效").Trim()));
				str = "灵甲护身加成";
				灵甲护身加成 = ((Config.IniReadValuee("气功配置", "灵甲护身加成").Trim() == "") ? 灵甲护身加成 : double.Parse(Config.IniReadValuee("气功配置", "灵甲护身加成").Trim()));
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "气功相关配置.ini 错误,请询问QQ593323947仔细查看更新文件:[错误位置:" + str + "]" + ex.Message);
			}
		}

		public void SetstConfig()
		{
			string str = "";
			try
			{
				str = "石头相关配置.ini";
				Config.Pathst = Application.StartupPath + "\\石头相关配置.ini";
				str = "商店混元金刚石";
				商店混元金刚石 = Config.IniReadValust("石头相关配置", "商店混元金刚石").Trim();
				str = "商店冰魄寒玉石防御";
				商店冰魄寒玉石防御 = Config.IniReadValust("石头相关配置", "商店冰魄寒玉石防御").Trim();
				str = "商店冰魄寒玉石武功防御";
				商店冰魄寒玉石武功防御 = Config.IniReadValust("石头相关配置", "商店冰魄寒玉石武功防御").Trim();
				str = "是否开启寒玉石随机属性";
				是否开启寒玉石随机属性 = int.Parse(Config.IniReadValust("石头相关配置", "是否开启寒玉石随机属性").Trim());
				str = "是否开启金刚石随机属性";
				是否开启金刚石随机属性 = int.Parse(Config.IniReadValust("石头相关配置", "是否开启金刚石随机属性").Trim());
				str = "商店属性石";
				商店属性石 = int.Parse(Config.IniReadValust("石头相关配置", "商店属性石").Trim());
				str = "商店属性石概率控制开启";
				商店属性石概率控制开启 = int.Parse(Config.IniReadValust("石头相关配置", "商店属性石概率控制开启").Trim());
				str = "出火属性石概率值";
				出火属性石概率值 = int.Parse(Config.IniReadValust("石头相关配置", "出火属性石概率值").Trim());
				str = "商店神秘金刚石";
				商店神秘金刚石 = Config.IniReadValust("石头相关配置", "商店神秘金刚石").Trim();
				str = "商店神秘寒玉石";
				商店神秘寒玉石 = Config.IniReadValust("石头相关配置", "商店神秘寒玉石").Trim();
				str = "商店神秘寒玉石生命";
				商店神秘寒玉石生命 = Config.IniReadValust("石头相关配置", "商店神秘寒玉石生命").Trim();
				str = "商店神秘寒玉石武防";
				商店神秘寒玉石武防 = Config.IniReadValust("石头相关配置", "商店神秘寒玉石武防").Trim();
				str = "商店神秘金刚石追伤";
				商店神秘金刚石追伤 = Config.IniReadValust("石头相关配置", "商店神秘金刚石追伤").Trim();
				str = "商店神秘金刚石武功";
				商店神秘金刚石武功 = Config.IniReadValust("石头相关配置", "商店神秘金刚石武功").Trim();
				str = "再造金刚石攻击";
				再造金刚石攻击 = Config.IniReadValust("石头相关配置", "再造金刚石攻击").Trim();
				str = "再造金刚石追伤";
				再造金刚石追伤 = Config.IniReadValust("石头相关配置", "再造金刚石追伤").Trim();
				str = "再造金刚石武功";
				再造金刚石武功 = Config.IniReadValust("石头相关配置", "再造金刚石武功").Trim();
				str = "再造金刚石命中";
				再造金刚石命中 = Config.IniReadValust("石头相关配置", "再造金刚石命中").Trim();
				str = "再造金刚石生命";
				再造金刚石生命 = Config.IniReadValust("石头相关配置", "再造金刚石生命").Trim();
				str = "再造寒玉石防御";
				再造寒玉石防御 = Config.IniReadValust("石头相关配置", "再造寒玉石防御").Trim();
				str = "再造寒玉石回避";
				再造寒玉石回避 = Config.IniReadValust("石头相关配置", "再造寒玉石回避").Trim();
				str = "再造寒玉石生命";
				再造寒玉石生命 = Config.IniReadValust("石头相关配置", "再造寒玉石生命").Trim();
				str = "再造寒玉石内功";
				再造寒玉石内功 = Config.IniReadValust("石头相关配置", "再造寒玉石内功").Trim();
				str = "再造寒玉石武防";
				再造寒玉石武防 = Config.IniReadValust("石头相关配置", "再造寒玉石武防").Trim();
				str = "再造冰魄寒玉石防御";
				再造冰魄寒玉石防御 = Config.IniReadValust("石头相关配置", "再造冰魄寒玉石防御").Trim();
				str = "再造冰魄寒玉石武防";
				再造冰魄寒玉石武防 = Config.IniReadValust("石头相关配置", "再造冰魄寒玉石武防").Trim();
				str = "再造混元金刚石攻击";
				再造混元金刚石攻击 = Config.IniReadValust("石头相关配置", "再造混元金刚石攻击").Trim();
				str = "再造混元金刚石武功";
				再造混元金刚石武功 = Config.IniReadValust("石头相关配置", "再造混元金刚石武功").Trim();
				str = "每次再造消耗设置";
				每次再造消耗设置 = int.Parse(Config.IniReadValust("石头相关配置", "每次再造消耗设置").Trim());
				str = "每次消耗的数量";
				每次消耗的数量 = int.Parse(Config.IniReadValust("石头相关配置", "每次消耗的数量").Trim());
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "配置文件 石头相关配置.ini 配置错误,请询问QQ593323947仔细查看更新文件:[错误位置:" + str + "]" + ex.Message);
			}
		}

		public void ChongwuConfig()
		{
			try
			{
				Config.Pathgg = Application.StartupPath + "\\宠物合成相关配置.ini";
				合成小蓝猫开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫开关").Trim());
				合成小蓝猫金币 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫金币").Trim());
				合成小蓝猫元宝 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫元宝").Trim());
				合成小蓝猫碎片ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫碎片ID").Trim());
				合成小蓝猫I咕咕鸡碎片I数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫I咕咕鸡碎片I数量").Trim());
				合成小蓝猫属性一 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫属性一").Trim());
				合成小蓝猫属性二 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫属性二").Trim());
				合成小蓝猫属性三 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫属性三").Trim());
				合成小蓝猫属性四 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成小蓝猫属性四").Trim());
				合成小蓝猫提示内容 = Config.IniReadValue("GameServer", "合成小蓝猫提示内容").Trim();
				无法合成小蓝猫提示内容 = Config.IniReadValue("GameServer", "无法合成小蓝猫提示内容").Trim();
				合成雪翼雕开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕开关").Trim());
				合成雪翼雕金币 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕金币").Trim());
				合成雪翼雕元宝 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕元宝").Trim());
				合成雪翼雕碎片ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕碎片ID").Trim());
				合成雪翼雕I龙猫碎片I数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕I龙猫碎片I数量").Trim());
				合成雪翼雕属性一 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕属性一").Trim());
				合成雪翼雕属性二 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕属性二").Trim());
				合成雪翼雕属性三 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕属性三").Trim());
				合成雪翼雕属性四 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成雪翼雕属性四").Trim());
				合成雪翼雕提示内容 = Config.IniReadValue("GameServer", "合成雪翼雕提示内容").Trim();
				无法合成雪翼雕提示内容 = Config.IniReadValue("GameServer", "无法合成雪翼雕提示内容").Trim();
				合成追风豹开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹开关").Trim());
				合成追风豹金币 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹金币").Trim());
				合成追风豹元宝 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹元宝").Trim());
				合成追风豹碎片ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹碎片ID").Trim());
				合成追风豹I雪翼雕碎片I数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹I雪翼雕碎片I数量").Trim());
				合成追风豹属性一 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹属性一").Trim());
				合成追风豹属性二 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹属性二").Trim());
				合成追风豹属性三 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹属性三").Trim());
				合成追风豹属性四 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成追风豹属性四").Trim());
				合成追风豹提示内容 = Config.IniReadValue("GameServer", "合成追风豹提示内容").Trim();
				无法合成追风豹提示内容 = Config.IniReadValue("GameServer", "无法合成追风豹提示内容").Trim();
				合成霸天虎开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎开关").Trim());
				合成霸天虎金币 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎金币").Trim());
				合成霸天虎元宝 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎元宝").Trim());
				合成霸天虎碎片ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎碎片ID").Trim());
				合成霸天虎I追风豹碎片I数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎I追风豹碎片I数量").Trim());
				合成霸天虎属性一 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎属性一").Trim());
				合成霸天虎属性二 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎属性二").Trim());
				合成霸天虎属性三 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎属性三").Trim());
				合成霸天虎属性四 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "合成霸天虎属性四").Trim());
				合成霸天虎提示内容 = Config.IniReadValue("GameServer", "合成霸天虎提示内容").Trim();
				无法合成霸天虎提示内容 = Config.IniReadValue("GameServer", "无法合成霸天虎提示内容").Trim();
				分解咕咕鸡开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解咕咕鸡开关").Trim());
				分解咕咕鸡ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解咕咕鸡ID").Trim());
				分解咕咕鸡ID数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解咕咕鸡ID数量").Trim());
				分解咕咕鸡提示内容 = Config.IniReadValue("GameServer", "分解咕咕鸡提示内容").Trim();
				无法分解咕咕鸡提示内容 = Config.IniReadValue("GameServer", "无法分解咕咕鸡提示内容").Trim();
				分解龙猫开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解龙猫开关").Trim());
				分解龙猫ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解龙猫ID").Trim());
				分解龙猫ID数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解龙猫ID数量").Trim());
				分解龙猫提示内容 = Config.IniReadValue("GameServer", "分解龙猫提示内容").Trim();
				无法分解龙猫提示内容 = Config.IniReadValue("GameServer", "无法分解龙猫提示内容").Trim();
				分解雪翼雕开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解雪翼雕开关").Trim());
				分解雪翼雕ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解雪翼雕ID").Trim());
				分解雪翼雕ID数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解雪翼雕ID数量").Trim());
				分解雪翼雕提示内容 = Config.IniReadValue("GameServer", "分解雪翼雕提示内容").Trim();
				无法分解雪翼雕提示内容 = Config.IniReadValue("GameServer", "无法分解雪翼雕提示内容").Trim();
				分解追风豹开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解追风豹开关").Trim());
				分解追风豹ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解追风豹ID").Trim());
				分解追风豹ID数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解追风豹ID数量").Trim());
				分解追风豹提示内容 = Config.IniReadValue("GameServer", "分解追风豹提示内容").Trim();
				无法分解追风豹提示内容 = Config.IniReadValue("GameServer", "无法分解追风豹提示内容").Trim();
				分解披风开关 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解披风开关").Trim());
				分解披风ID = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解披风ID").Trim());
				分解披风ID数量 = int.Parse(Config.IniReadValugk("宠物合成相关配置", "分解披风ID数量").Trim());
				分解披风提示内容 = Config.IniReadValue("GameServer", "分解披风提示内容").Trim();
				无法分解披风提示内容 = Config.IniReadValue("GameServer", "无法分解披风提示内容").Trim();
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "宠物合成相关配置.ini 配置错误,请询问QQ593323947仔细查看更新文件:" + ex.Message);
			}
		}

		public void SetgjConfig()
		{
			try
			{
				Config.Pathgj = Application.StartupPath + "\\挂机相关配置.ini";
				离线挂机数量 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机数量").Trim());
				在线挂机打怪命令 = Config.IniReadValugj("挂机相关配置", "在线挂机打怪命令").Trim();
				停止挂机打怪命令 = Config.IniReadValugj("挂机相关配置", "停止挂机打怪命令").Trim();
				挂机奖励是否开启 = int.Parse(Config.IniReadValugj("挂机相关配置", "挂机奖励是否开启").Trim());
				金刚石攻击 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石攻击").Trim());
				金刚石气功 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石气功").Trim());
				金刚石命中 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石命中").Trim());
				金刚石生命 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石生命").Trim());
				金刚石武功 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石武功").Trim());
				金刚石追伤 = long.Parse(Config.IniReadValugj("挂机相关配置", "金刚石追伤").Trim());
				寒玉石防御 = long.Parse(Config.IniReadValugj("挂机相关配置", "寒玉石防御").Trim());
				寒玉石回避 = long.Parse(Config.IniReadValugj("挂机相关配置", "寒玉石回避").Trim());
				寒玉石内功 = long.Parse(Config.IniReadValugj("挂机相关配置", "寒玉石内功").Trim());
				寒玉石武防 = int.Parse(Config.IniReadValugj("挂机相关配置", "寒玉石防御").Trim());
				寒玉石生命 = long.Parse(Config.IniReadValugj("挂机相关配置", "寒玉石生命").Trim());
				混元金刚石气功 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石气功").Trim());
				混元金刚石命中 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石命中").Trim());
				混元金刚石生命 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石生命").Trim());
				混元金刚石攻击 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石攻击").Trim());
				混元金刚石武功 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石武功").Trim());
				混元金刚石追伤 = long.Parse(Config.IniReadValugj("挂机相关配置", "混元金刚石追伤").Trim());
				冰魄寒玉石防御 = long.Parse(Config.IniReadValugj("挂机相关配置", "冰魄寒玉石防御").Trim());
				冰魄寒玉石回避 = long.Parse(Config.IniReadValugj("挂机相关配置", "冰魄寒玉石回避").Trim());
				冰魄寒玉石内功 = long.Parse(Config.IniReadValugj("挂机相关配置", "冰魄寒玉石内功").Trim());
				冰魄寒玉石武防 = long.Parse(Config.IniReadValugj("挂机相关配置", "冰魄寒玉石武防").Trim());
				冰魄寒玉石生命 = long.Parse(Config.IniReadValugj("挂机相关配置", "冰魄寒玉石生命").Trim());
				热血石气功 = long.Parse(Config.IniReadValugj("挂机相关配置", "热血石气功").Trim());
				离线挂机打怪命令 = Config.IniReadValugj("挂机相关配置", "离线挂机打怪命令").Trim();
				离线打怪GS监控 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线打怪GS监控").Trim());
				挂机打怪自动发言 = Config.IniReadValugj("挂机相关配置", "挂机打怪自动发言").Trim();
				挂机奖励 = Config.IniReadValugj("挂机相关配置", "挂机奖励").Trim();
				挂机奖励最大元宝 = int.Parse(Config.IniReadValugj("挂机相关配置", "挂机奖励最大元宝").Trim());
				挂机奖励最大武勋 = int.Parse(Config.IniReadValugj("挂机相关配置", "挂机奖励最大武勋").Trim());
				VIP挂机奖励 = Config.IniReadValugj("挂机相关配置", "VIP挂机奖励").Trim();
				VIP挂机奖励最大元宝 = int.Parse(Config.IniReadValugj("挂机相关配置", "VIP挂机奖励最大元宝").Trim());
				VIP挂机奖励最大武勋 = int.Parse(Config.IniReadValugj("挂机相关配置", "VIP挂机奖励最大武勋").Trim());
				离线挂机命令 = Config.IniReadValugj("挂机相关配置", "离线挂机命令").Trim();
				离线挂机所需物品ID = Config.IniReadValugj("挂机相关配置", "离线挂机所需物品ID").Trim();
				离线挂机经验是否开启 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机经验是否开启").Trim());
				离线挂机经验限制最低等级 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机经验限制最低等级").Trim());
				离线挂机奖励经验时间 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机奖励经验时间").Trim());
				离线挂机经验数 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机经验数").Trim());
				离线挂机奖励 = Config.IniReadValugj("挂机相关配置", "离线挂机奖励").Trim();
				离线VIP挂机奖励 = Config.IniReadValugj("挂机相关配置", "离线VIP挂机奖励").Trim();
				离线挂机奖励是否开启 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机奖励是否开启").Trim());
				离线挂机奖励限制最低等级 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机奖励限制最低等级").Trim());
				离线挂机奖励发送时间间隔 = int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机奖励发送时间间隔").Trim());
				自定义挂机地图 = Config.IniReadValugj("挂机相关配置", "自定义挂机地图").Trim();
				自定义挂机地图坐标 = Config.IniReadValugj("挂机相关配置", "自定义挂机地图坐标").Trim();
				离线挂机地图 = ((Config.IniReadValugj("挂机相关配置", "离线挂机地图").Trim() == "") ? 离线挂机地图 : int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机地图").Trim()));
				离线挂机等级 = ((Config.IniReadValugj("挂机相关配置", "离线挂机等级").Trim() == "") ? 离线挂机等级 : int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机等级").Trim()));
				是否开启离线挂机 = ((Config.IniReadValugj("挂机相关配置", "是否开启离线挂机").Trim() == "") ? 是否开启离线挂机 : int.Parse(Config.IniReadValugj("挂机相关配置", "是否开启离线挂机").Trim()));
				挂机奖励时间周期 = ((Config.IniReadValugj("挂机相关配置", "挂机奖励时间周期").Trim() == "") ? 挂机奖励时间周期 : int.Parse(Config.IniReadValugj("挂机相关配置", "挂机奖励时间周期").Trim()));
				离线挂机是否开启 = ((Config.IniReadValugj("挂机相关配置", "离线挂机是否开启").Trim() == "") ? 离线挂机是否开启 : int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机是否开启").Trim()));
				离线挂机等级限制 = ((Config.IniReadValugj("挂机相关配置", "离线挂机等级限制").Trim() == "") ? 离线挂机等级限制 : ((double)int.Parse(Config.IniReadValugj("挂机相关配置", "离线挂机等级限制").Trim())));
				假人自动喊话开关 = int.Parse(Config.IniReadValugj("挂机相关配置", "假人自动喊话开关").Trim());
				try
				{
					string text = (Config.IniReadValugj("挂机相关配置", "挂机奖励地图").Trim() == "") ? "" : Config.IniReadValugj("挂机相关配置", "挂机奖励地图").Trim();
					挂机奖励地图.Clear();
					if (text != "")
					{
						string text2 = text;
						char[] separator = new char[1]
						{
							';'
						};
						string[] array = text2.Split(separator);
						string[] array2 = array;
						string[] array3 = array2;
						string[] array4 = array3;
						string[] array5 = array4;
						string[] array6 = array5;
						string[] array7 = array6;
						foreach (string s in array7)
						{
							try
							{
								int item = int.Parse(s);
								挂机奖励地图.Add(item);
							}
							catch
							{
							}
						}
					}
				}
				catch (Exception)
				{
				}
			}
			catch (Exception ex2)
			{
				Form1.WriteLine(1, "配置文件 挂机配置.ini 配置错误,请询问QQ593323947仔细查看更新文件:" + ex2.Message);
				Environment.Exit(0);
			}
		}

		public static void 得分清零()
		{
			foreach (Players value in allConnectedChars.Values)
			{
				value.得分统计 = 0;
				value.答案选择 = "0";
				value.保存人物的数据();
				value.保存人物数据存储过程();
			}
		}

		public void Set科举出题题库()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库1", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库出错----没有题库数据");
			}
			else
			{
				科举出题.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类 科举系统类 = new 科举系统类
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类 value = 科举系统类;
					科举出题.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库2()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库2", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库2出错----没有题库数据");
			}
			else
			{
				科举出题2.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类2 科举系统类 = new 科举系统类2
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类2 value = 科举系统类;
					科举出题2.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库2据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库3()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库3", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库3出错----没有题库数据");
			}
			else
			{
				科举出题3.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类3 科举系统类 = new 科举系统类3
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类3 value = 科举系统类;
					科举出题3.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库3据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库4()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库4", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库4出错----没有题库数据");
			}
			else
			{
				科举出题4.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类4 科举系统类 = new 科举系统类4
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类4 value = 科举系统类;
					科举出题4.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库4据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库5()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库5", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库5出错----没有题库数据");
			}
			else
			{
				科举出题5.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类5 科举系统类 = new 科举系统类5
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类5 value = 科举系统类;
					科举出题5.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库5据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库6()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库6", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库6出错----没有题库数据");
			}
			else
			{
				科举出题6.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类6 科举系统类 = new 科举系统类6
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类6 value = 科举系统类;
					科举出题6.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库6据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set科举出题题库7()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM 题库7", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载题库7出错----没有题库数据");
			}
			else
			{
				科举出题7.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					科举系统类7 科举系统类 = new 科举系统类7
					{
						序号 = (int)dBToDataTable.Rows[i]["INDEX"],
						标题 = dBToDataTable.Rows[i]["题目"].ToString(),
						选择答案 = dBToDataTable.Rows[i]["选项"].ToString(),
						正确答案 = dBToDataTable.Rows[i]["答案"].ToString(),
						元宝 = (int)dBToDataTable.Rows[i]["元宝"],
						积分 = (int)dBToDataTable.Rows[i]["积分"],
						武勋 = (int)dBToDataTable.Rows[i]["武勋"]
					};
					科举系统类7 value = 科举系统类;
					科举出题7.Add(i, value);
				}
				Form1.WriteLine(3, "加载题库7据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetDB首爆石头()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM TBL_首爆石头奖励", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载石头奖励数据完成----没有首爆奖励数据");
			}
			else
			{
				Set首爆石头.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						首爆石头 首爆石头 = new 首爆石头();
						首爆石头.id = (int)dBToDataTable.Rows[i]["ID"];
						首爆石头.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["物品属性"];
						首爆石头.FLD_YB1 = (int)dBToDataTable.Rows[i]["第一个奖励"];
						首爆石头.FLD_YB2 = (int)dBToDataTable.Rows[i]["第二个奖励"];
						首爆石头.FLD_YB3 = (int)dBToDataTable.Rows[i]["第三个奖励"];
						首爆石头.FLD_YB4 = (int)dBToDataTable.Rows[i]["第四个奖励"];
						首爆石头.FLD_YB5 = (int)dBToDataTable.Rows[i]["第五个奖励"];
						Set首爆石头.Add(首爆石头);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载石头奖励数据 出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(3, "加载石头奖励数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetDB首爆()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM TBL_首爆物品奖励", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载首爆奖励数据完成----没有首爆奖励数据");
			}
			else
			{
				Set首爆.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						首爆 首爆 = new 首爆();
						首爆.FLD_NAME1 = (int)dBToDataTable.Rows[i]["首爆物品ID"];
						首爆.FLD_YB1 = (int)dBToDataTable.Rows[i]["第一个奖励"];
						首爆.FLD_YB2 = (int)dBToDataTable.Rows[i]["第二个奖励"];
						首爆.FLD_YB3 = (int)dBToDataTable.Rows[i]["第三个奖励"];
						首爆.FLD_YB4 = (int)dBToDataTable.Rows[i]["第四个奖励"];
						首爆.FLD_YB5 = (int)dBToDataTable.Rows[i]["第五个奖励"];
						Set首爆.Add(首爆);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载首爆奖励数据 出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(3, "加载首爆奖励数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetDB自定义回收()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT * FROM TBL_自定义回收", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载自定义回收数据完成----没有自定义回收数据");
			}
			else
			{
				Sst自定义回收.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						自定义回收 自定义回收 = new 自定义回收();
						自定义回收.id = (int)dBToDataTable.Rows[i]["ID"];
						自定义回收.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						自定义回收.FLD_NAME = (string)dBToDataTable.Rows[i]["FLD_NAME"];
						自定义回收.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
						自定义回收.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
						自定义回收.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
						自定义回收.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
						自定义回收.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
						自定义回收.FLD_YB1 = (int)dBToDataTable.Rows[i]["元宝"];
						自定义回收.FLD_JF1 = (int)dBToDataTable.Rows[i]["积分"];
						自定义回收.FLD_WX1 = (int)dBToDataTable.Rows[i]["武勋"];
						Sst自定义回收.Add(自定义回收);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载自定义回收数据 出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(3, "加载自定义回收数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public static bool 检查数据库配置()
		{
			using (SqlConnection sqlConnection = new SqlConnection(DBA.getstrConnection("rxjhaccount")))
			{
				try
				{
					sqlConnection.Open();
				}
				catch
				{
					Form1.WriteLine(1, "数据库rxjhaccount配置错误，无法连接");
					return false;
				}
				finally
				{
					sqlConnection.Close();
				}
			}
			using (SqlConnection sqlConnection2 = new SqlConnection(DBA.getstrConnection("GameServer")))
			{
				try
				{
					sqlConnection2.Open();
				}
				catch
				{
					Form1.WriteLine(1, "数据库rxjhgame配置错误，无法连接");
					return false;
				}
				finally
				{
					sqlConnection2.Close();
				}
			}
			using (SqlConnection sqlConnection3 = new SqlConnection(DBA.getstrConnection("PublicDb")))
			{
				try
				{
					sqlConnection3.Open();
				}
				catch
				{
					Form1.WriteLine(1, "数据库PublicDb配置错误，无法连接");
					return false;
				}
				finally
				{
					sqlConnection3.Close();
				}
			}
			return true;
		}

		public void SetConfig2()
		{
			DbClass dbClass = new DbClass();
			dbClass.ServerDb = "rxjhaccount";
			dbClass.SqlConnect = string.Format("Data Source={0};uid={1};pwd={2};database={3};Packet Size=4096;Pooling=true;Max Pool Size=512;Min Pool Size=1", Config.IniReadValue("rxjhaccount", "Server").Trim(), Config.IniReadValue("rxjhaccount", "UserName").Trim(), Config.IniReadValue("rxjhaccount", "PassWord").Trim(), Config.IniReadValue("rxjhaccount", "DataName").Trim());
			Db.Add("rxjhaccount", dbClass);
			dbClass = new DbClass();
			dbClass.ServerDb = "GameServer";
			dbClass.SqlConnect = string.Format("Data Source={0};uid={1};pwd={2};database={3};Packet Size=4096;Pooling=true;Max Pool Size=512;Min Pool Size=1", Config.IniReadValue("GameServer", "Server").Trim(), Config.IniReadValue("GameServer", "UserName").Trim(), Config.IniReadValue("GameServer", "PassWord").Trim(), Config.IniReadValue("GameServer", "DataName").Trim());
			Db.Add("GameServer", dbClass);
			dbClass = new DbClass();
			dbClass.ServerDb = "PublicDb";
			dbClass.SqlConnect = string.Format("Data Source={0};uid={1};pwd={2};database={3};Packet Size=4096;Pooling=true;Max Pool Size=512;Min Pool Size=1", Config.IniReadValue("PublicDb", "Server").Trim(), Config.IniReadValue("PublicDb", "UserName").Trim(), Config.IniReadValue("PublicDb", "PassWord").Trim(), Config.IniReadValue("PublicDb", "DataName").Trim());
			Db.Add("PublicDb", dbClass);
			dbClass = new DbClass();
			dbClass.ServerDb = "bbgDb";
			dbClass.SqlConnect = string.Format("Data Source={0};uid={1};pwd={2};database={3};Packet Size=4096;Pooling=true;Max Pool Size=512;Min Pool Size=1", Config.IniReadValue("bbgDb", "Server").Trim(), Config.IniReadValue("bbgDb", "UserName").Trim(), Config.IniReadValue("bbgDb", "PassWord").Trim(), Config.IniReadValue("bbgDb", "DataName").Trim());
			Db.Add("bbgDb", dbClass);
			if (查非法物品 == 2)
			{
				dbClass = new DbClass();
				dbClass.ServerDb = "WebDb";
				dbClass.SqlConnect = string.Format("Data Source={0};uid={1};pwd={2};database={3};Packet Size=4096;Pooling=true;Max Pool Size=512;Min Pool Size=1", Config.IniReadValue("WebDb", "Server").Trim(), Config.IniReadValue("WebDb", "UserName").Trim(), Config.IniReadValue("WebDb", "PassWord").Trim(), Config.IniReadValue("WebDb", "DataName").Trim());
				Db.Add("WebDb", dbClass);
			}
		}

		public static bool 检查物品是否被锁定(int pid)
		{
			return 锁定物品列表.Contains(pid);
		}

		public void Set冲关地图()
		{
			try
			{
				冲关地图list.Clear();
				string[] array = 冲关地图.Split(';');
				if (array.Length > 1)
				{
					for (int i = 0; i < array.Length; i++)
					{
						string[] array2 = array[i].Split(',');
						if (array2.Length > 3 && !冲关地图list.ContainsKey(array2[0]))
						{
							冲关地图类 冲关地图类 = new 冲关地图类();
							冲关地图类.地图名 = array2[0];
							冲关地图类.地图ID = int.Parse(array2[1]);
							冲关地图类.ItmeID = int.Parse(array2[2]);
							冲关地图类.进入时间 = int.Parse(array2[3]);
							冲关地图list.Add(冲关地图类.地图名, 冲关地图类);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(3, "加载冲关地图出错---" + ex.Message);
			}
		}

		public static 任务类 GetRW(int 任务ID)
		{
			if (!任务list.TryGetValue(任务ID, out 任务类 value))
			{
				return null;
			}
			return value;
		}

		public void 加载转生次数奖励()
		{
			string sqlCommand = "SELECT * FROM 转生次数奖励";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载转生次数奖励出错----没有转生次数奖励数据");
			}
			else
			{
				转生次数数据.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					转生次数类 转生次数类 = new 转生次数类();
					转生次数类.转生次数 = (int)dBToDataTable.Rows[i]["转生次数"];
					转生次数类.武勋 = (int)dBToDataTable.Rows[i]["武勋"];
					转生次数类.元宝 = (int)dBToDataTable.Rows[i]["元宝"];
					转生次数类.生命 = (int)dBToDataTable.Rows[i]["生命"];
					转生次数类.攻击 = (int)dBToDataTable.Rows[i]["攻击"];
					转生次数类.防御 = (int)dBToDataTable.Rows[i]["防御"];
					转生次数类.回避 = (int)dBToDataTable.Rows[i]["回避"];
					转生次数类.命中 = (int)dBToDataTable.Rows[i]["命中"];
					转生次数类.内功 = (int)dBToDataTable.Rows[i]["内功"];
					转生次数类.套装ID = (int)dBToDataTable.Rows[i]["套装ID"];
					转生次数类.金钱 = dBToDataTable.Rows[i]["金钱"].ToString();
					转生次数类.单件物品 = dBToDataTable.Rows[i]["单件物品"].ToString();
					转生次数类.会员等级 = (int)dBToDataTable.Rows[i]["会员等级"];
					转生次数数据.Add(i, 转生次数类);
				}
				Form1.WriteLine(3, "加载转生次数奖励数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public static int GetRandomSeed()
		{
			byte[] array = new byte[4];
			new RNGCryptoServiceProvider().GetBytes(array);
			return BitConverter.ToInt32(array, 0);
		}

		public void 加载攻城数据()
		{
			string sqlCommand = "SELECT * FROM 攻城城主";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "GameServer");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count != 0)
			{
				攻城数据list.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					攻城数据 攻城数据 = new 攻城数据();
					攻城数据.ID = (int)dBToDataTable.Rows[i]["帮派ID"];
					攻城数据.行会名字 = dBToDataTable.Rows[i]["攻城行会名"].ToString();
					攻城数据.城主名字 = dBToDataTable.Rows[i]["城主名字"].ToString();
					攻城数据list.Add(攻城数据.ID, 攻城数据);
				}
				Form1.WriteLine(3, "加载攻城数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set攻城战()
		{
			攻城站区域.Clear();
			坐标Class 坐标Class = new 坐标Class();
			坐标Class.Rxjh_name = "攻城战区域";
			坐标Class.Rxjh_Map = 攻城战地图;
			坐标Class.Rxjh_X = 攻城战X坐标;
			坐标Class.Rxjh_Y = 攻城战Y坐标;
			坐标Class.Rxjh_Z = 15f;
			攻城站区域.Add(坐标Class);
			Form1.WriteLine(3, "加载攻城站区域成功");
		}

		public void Set乱斗地区()
		{
			坐标Class 坐标Class = new 坐标Class();
			坐标Class.Rxjh_name = "乱斗地区";
			坐标Class.Rxjh_Map = 乱斗地图;
			坐标Class.Rxjh_X = 乱斗地区X坐标;
			坐标Class.Rxjh_Y = 乱斗地区Y坐标;
			坐标Class.Rxjh_Z = 15f;
			乱斗地区.Add(坐标Class);
			Form1.WriteLine(3, "加载排位赛地区成功");
		}

		public void 世界BOSS开启()
		{
			BOSS倒计时秒 = 120;
		}

		public void 加载乱斗排名奖励()
		{
			string sqlCommand = "SELECT * FROM 乱斗排名奖励";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载排位赛排名奖励出错----没有排位赛排名奖励数据");
			}
			else
			{
				乱斗排名数据.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					乱斗排名类 乱斗排名类 = new 乱斗排名类();
					乱斗排名类.乱斗排名 = (int)dBToDataTable.Rows[i]["乱斗排名"];
					乱斗排名类.乱斗名次 = (int)dBToDataTable.Rows[i]["乱斗名次"];
					乱斗排名类.元宝 = (int)dBToDataTable.Rows[i]["元宝"];
					乱斗排名类.武勋 = (int)dBToDataTable.Rows[i]["武勋"];
					乱斗排名数据.Add(i, 乱斗排名类);
				}
				Form1.WriteLine(3, "加载排位赛排名奖励数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void 加载段位提示数据()
		{
			string sqlCommand = "SELECT * FROM 段位提示";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(1, "加载段位提示出错----没有段位提示数据");
			}
			else
			{
				段位提示数据.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					段位提示 段位提示 = new 段位提示();
					段位提示.积分最小 = (int)dBToDataTable.Rows[i]["积分最小"];
					段位提示.积分最大 = (int)dBToDataTable.Rows[i]["积分最大"];
					段位提示.段位 = dBToDataTable.Rows[i]["段位"].ToString();
					段位提示.上线提示 = dBToDataTable.Rows[i]["上线提示"].ToString();
					段位提示.提示颜色 = (int)dBToDataTable.Rows[i]["提示颜色"];
					段位提示.攻击 = (int)dBToDataTable.Rows[i]["攻击"];
					段位提示.防御 = (int)dBToDataTable.Rows[i]["防御"];
					段位提示.气功 = (int)dBToDataTable.Rows[i]["气功"];
					段位提示数据.Add(i, 段位提示);
				}
				Form1.WriteLine(3, "加载段位提示数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set任务物品()
		{
			string sqlCommand = "SELECT * FROM TBL_任务物品";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载任务物品数据出错----没有检查数据");
			}
			else
			{
				任务需要物品list.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					任务需要物品 任务需要物品 = new 任务需要物品();
					任务需要物品.任务物品 = (int)dBToDataTable.Rows[i]["任务物品"];
					任务需要物品.需要数量 = (int)dBToDataTable.Rows[i]["需要数量"];
					任务需要物品.任务ID = (int)dBToDataTable.Rows[i]["任务ID"];
					任务需要物品.任务阶段 = (int)dBToDataTable.Rows[i]["任务阶段"];
					任务需要物品list.Add(任务需要物品.任务物品, 任务需要物品);
				}
				Form1.WriteLine(3, "加载任务物品数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetBossInfo()
		{
			string sqlCommand = "SELECT * FROM TBL_BOSS设置";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载BOSS设置数据出错----没有检查数据");
			}
			else
			{
				BOSS设置list.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					BOSS地图 bOSS地图 = new BOSS地图();
					bOSS地图.ID = (int)dBToDataTable.Rows[i]["ID"];
					bOSS地图.地图ID = (int)dBToDataTable.Rows[i]["FLD_MID"];
					bOSS地图.地图名字 = dBToDataTable.Rows[i]["FLD_MINAME"].ToString();
					bOSS地图.怪物ID = (int)dBToDataTable.Rows[i]["FLD_BOSSID"];
					bOSS地图.怪物名字 = dBToDataTable.Rows[i]["FLD_BOSSNAME"].ToString();
					bOSS地图.携带物品ID = (int)dBToDataTable.Rows[i]["FLD_DROPID"];
					bOSS地图.携带物品名字 = dBToDataTable.Rows[i]["FLD_DROPNAME"].ToString();
					bOSS地图.出现时间 = (int)dBToDataTable.Rows[i]["FLD_TIME"];
					bOSS地图.坐标X = (int)dBToDataTable.Rows[i]["FLD_X"];
					bOSS地图.坐标Y = (int)dBToDataTable.Rows[i]["FLD_Y"];
					bOSS地图.是否可以进入 = false;
					BOSS设置list.Add(bOSS地图.ID, bOSS地图);
				}
				Form1.WriteLine(3, "加载BOSS地图怪物设置完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set转职属性()
		{
			string sqlCommand = "SELECT * FROM TBL_转职属性";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载转职属性数据出错----没有转职属性数据");
			}
			else
			{
				转职属性.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					转职属性类 转职属性类 = new 转职属性类();
					转职属性类.转职等级 = (int)dBToDataTable.Rows[i]["FLD_转职等级"];
					转职属性类.增加攻击 = (int)dBToDataTable.Rows[i]["FLD_增加攻击"];
					转职属性类.增加防御 = (int)dBToDataTable.Rows[i]["FLD_增加防御"];
					转职属性类.增加MP = (int)dBToDataTable.Rows[i]["FLD_增加魔法"];
					转职属性类.增加HP = (int)dBToDataTable.Rows[i]["FLD_增加生命"];
					转职属性.Add(转职属性类);
				}
				Form1.WriteLine(3, "加载转职属性数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set任务传书数据()
		{
			string sqlCommand = "SELECT * FROM TBL_任务系统";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载任务传书数据出错----没有任务传书数据");
			}
			else
			{
				任务公告list.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					任务系统 任务系统 = new 任务系统();
					任务系统.任务ID = (int)dBToDataTable.Rows[i]["任务ID"];
					任务系统.任务NPC = (int)dBToDataTable.Rows[i]["任务正邪"];
					任务系统.任务等级 = (int)dBToDataTable.Rows[i]["任务等级"];
					任务系统.NPC名字 = dBToDataTable.Rows[i]["NPC名字"].ToString();
					任务系统.任务传书内容 = dBToDataTable.Rows[i]["任务传书"].ToString();
					任务公告list.Add(任务系统.任务ID, 任务系统);
				}
				Form1.WriteLine(3, "加载任务传书数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set百宝物品()
		{
			string sqlCommand = "SELECT * FROM ITEMSELL ORDER BY id";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "bbgDb");
			if (dBToDataTable != null)
			{
				if (dBToDataTable.Rows.Count == 0)
				{
					Form1.WriteLine(3, "加载百宝阁物品出错----没有移动数据");
				}
				else
				{
					int num = 0;
					百宝阁物品.Clear();
					try
					{
						for (int i = 0; i < dBToDataTable.Rows.Count; i++)
						{
							bbg物品类 bbg物品类 = new bbg物品类();
							bbg物品类.ID = (int)dBToDataTable.Rows[i]["ID"];
							bbg物品类.物品ID = (int)dBToDataTable.Rows[i]["FLD_PID"];
							bbg物品类.物品价格 = (int)dBToDataTable.Rows[i]["FLD_PRICE"];
							bbg物品类.物品名称 = (string)dBToDataTable.Rows[i]["FLD_NAME"];
							bbg物品类.物品类型 = (int)dBToDataTable.Rows[i]["FLD_TYPE"];
							bbg物品类.返还积分 = (int)dBToDataTable.Rows[i]["FLD_RETURN"];
							bbg物品类.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
							bbg物品类.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
							bbg物品类.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
							bbg物品类.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
							bbg物品类.FLD_MAGIC5 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
							bbg物品类.FLD_绑定 = ((int)dBToDataTable.Rows[i]["FLD_绑定"] != 0);
							num = bbg物品类.物品ID;
							百宝阁物品.Add((int)dBToDataTable.Rows[i]["FLD_PID"], bbg物品类);
						}
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载百宝阁物品" + num.ToString() + "出错 错误" + ex.Message);
					}
					Form1.WriteLine(3, "加载百宝阁物品数据完成" + dBToDataTable.Rows.Count.ToString());
				}
				dBToDataTable.Dispose();
			}
		}

		public void set会员装备()
		{
			string sqlCommand = "SELECT * FROM TBL_会员装备";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载会员装备出错----没有数据");
			}
			else
			{
				会员物品.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					会员装备类 会员装备类 = new 会员装备类();
					会员装备类.物品ID = (int)dBToDataTable.Rows[i]["FLD_ID"];
					会员装备类.名称 = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
					会员装备类.职业 = (int)dBToDataTable.Rows[i]["FLD_JOB"];
					会员装备类.物品正邪 = (int)dBToDataTable.Rows[i]["FLD_ZX"];
					会员装备类.物品性别 = (int)dBToDataTable.Rows[i]["FLD_SEX"];
					会员装备类.物品类型 = (int)dBToDataTable.Rows[i]["FLD_RESIDE"];
					会员装备类.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
					会员装备类.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					会员装备类.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					会员装备类.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					会员装备类.FLD_MAGIC5 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					会员装备类.FLD_绑定 = true;
					会员物品.Add((int)dBToDataTable.Rows[i]["ID"], 会员装备类);
				}
			}
			dBToDataTable.Dispose();
		}

		public void Set套装物品()
		{
			string sqlCommand = "SELECT * FROM TBL_套装物品";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载套装物品出错----没有套装物品数据");
			}
			else
			{
				套装物品.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					套装物品类 套装物品类 = new 套装物品类();
					套装物品类.套装类型 = (int)dBToDataTable.Rows[i]["FLD_TYPE"];
					套装物品类.物品类型 = (int)dBToDataTable.Rows[i]["FLD_RESIDE"];
					套装物品类.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
					套装物品类.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					套装物品类.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					套装物品类.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					套装物品类.FLD_MAGIC5 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					套装物品类.FLD_绑定 = true;
					套装物品.Add((int)dBToDataTable.Rows[i]["ID"], 套装物品类);
				}
				Form1.WriteLine(3, "加载套装物品数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set冲级奖励物品()
		{
			string sqlCommand = "SELECT * FROM TBL_冲级奖品";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载冲级奖励物品出错----没有冲级奖励物品数据");
			}
			else
			{
				冲级奖励物品.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					套装物品类 套装物品类 = new 套装物品类();
					套装物品类.wpID = (int)dBToDataTable.Rows[i]["FLD_PID"];
					套装物品类.套装类型 = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
					套装物品类.物品类型 = (int)dBToDataTable.Rows[i]["FLD_PID_TYPE"];
					套装物品类.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
					套装物品类.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					套装物品类.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					套装物品类.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					套装物品类.FLD_MAGIC5 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					套装物品类.FLD_武勋 = (int)dBToDataTable.Rows[i]["FLD_武勋"];
					套装物品类.FLD_绑定 = ((int)dBToDataTable.Rows[i]["FLD_绑定"] != 0);
					冲级奖励物品.Add((int)dBToDataTable.Rows[i]["ID"], 套装物品类);
				}
				Form1.WriteLine(3, "加载冲级奖励物品数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetKill()
		{
			if (!(Keyk.CpuID != KeykF.CpuID) && !(Keyk.DriveID != KeykF.DriveID) && !(Keyk.IP != KeykF.IP) && !(Keyk.Mac != KeykF.Mac) && KeykF.IP.Length >= 4 && KeykF.Mac.Length >= 4 && Keyk.IP.Length >= 4)
			{
				int length = Keyk.Mac.Length;
			}
			string sqlCommand = "SELECT * FROM TBL_屏蔽字符";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载过滤出错----没有屏蔽数据");
			}
			else
			{
				Kill.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					KillClass killClass = new KillClass();
					killClass.Txt = dBToDataTable.Rows[i]["txt"].ToString();
					killClass.Sffh = (int)dBToDataTable.Rows[i]["sffh"];
					Kill.Add(killClass);
				}
				Form1.WriteLine(3, "加载过滤数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set公告()
		{
			string sqlCommand = "SELECT * FROM TBL_自动公告";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载公告出错----没有公告数据");
			}
			else
			{
				公告.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					公告类 公告类 = new 公告类();
					公告类.msg = dBToDataTable.Rows[i]["txt"].ToString();
					公告类.type = (int)dBToDataTable.Rows[i]["type"];
					公告.Add(i, 公告类);
				}
				Form1.WriteLine(3, "加载公告数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set安全区()
		{
			string sqlCommand = "SELECT * FROM TBL_安全区";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable != null)
			{
				if (dBToDataTable.Rows.Count == 0)
				{
					Form1.WriteLine(3, "加载安全区出错----没有数据");
				}
				else
				{
					安全区.Clear();
					for (int i = 0; i < dBToDataTable.Rows.Count; i++)
					{
						安全区Class 安全区Class = new 安全区Class();
						安全区Class.MapID = (int)dBToDataTable.Rows[i]["MAP"];
						安全区Class.S_MINX = float.Parse(dBToDataTable.Rows[i]["S_MINX"].ToString());
						安全区Class.S_MINY = float.Parse(dBToDataTable.Rows[i]["S_MINY"].ToString());
						安全区Class.S_MAXX = float.Parse(dBToDataTable.Rows[i]["S_MAXX"].ToString());
						安全区Class.S_MAXY = float.Parse(dBToDataTable.Rows[i]["S_MAXY"].ToString());
						安全区.Add(安全区Class.MapID, 安全区Class);
					}
					Form1.WriteLine(3, "加载安全区数据完成" + dBToDataTable.Rows.Count.ToString());
				}
				dBToDataTable.Dispose();
			}
			坐标Class 坐标Class = new 坐标Class();
			坐标Class.Rxjh_name = "宣战区";
			坐标Class.Rxjh_Map = int.Parse(dt[0]);
			坐标Class.Rxjh_X = float.Parse(dt[1]);
			坐标Class.Rxjh_Y = float.Parse(dt[2]);
			坐标Class.Rxjh_Z = 15f;
			对练区.Add(坐标Class);
			坐标Class 坐标Class2 = new 坐标Class();
			坐标Class2.Rxjh_name = "复仇区";
			坐标Class2.Rxjh_Map = int.Parse(fc[0]);
			坐标Class2.Rxjh_X = float.Parse(fc[1]);
			坐标Class2.Rxjh_Y = float.Parse(fc[2]);
			坐标Class2.Rxjh_Z = 15f;
			复仇区.Add(坐标Class2);
		}

		public void Set移动()
		{
			string sqlCommand = "SELECT * FROM TBL_地图列表 WHERE (X IS NOT NULL)";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载自定义移动出错----没有移动数据");
			}
			else
			{
				移动.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					坐标Class 坐标Class = new 坐标Class();
					坐标Class.Rxjh_name = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
					坐标Class.Rxjh_Map = (int)dBToDataTable.Rows[i]["FLD_MID"];
					坐标Class.Rxjh_X = float.Parse(dBToDataTable.Rows[i]["X"].ToString());
					坐标Class.Rxjh_Y = float.Parse(dBToDataTable.Rows[i]["Y"].ToString());
					坐标Class.Rxjh_Z = 15f;
					移动.Add(坐标Class);
				}
				Form1.WriteLine(3, "加载地图数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetLever()
		{
			lever.Clear();
			for (int i = 0; i < 256; i++)
			{
				if (i == 0)
				{
					lever.Add(0, 100.0);
				}
				else if (i <= 10)
				{
					lever.Add(i, lever[i - 1] * 1.5);
				}
				else if (i <= 35)
				{
					lever.Add(i, lever[i - 1] * 1.4);
				}
				else if (i <= 60)
				{
					lever.Add(i, lever[i - 1] + (lever[i - 1] - lever[i - 2]) * 1.2);
				}
				else if (i <= 80)
				{
					lever.Add(i, lever[i - 1] + (lever[i - 1] - lever[i - 2]) * 1.11);
				}
				else if (i <= 100)
				{
					lever.Add(i, lever[i - 1] + (lever[i - 1] - lever[i - 2]) * 1.06);
				}
				else
				{
					lever.Add(i, lever[i - 1] + (lever[i - 1] - lever[i - 2]) * 1.02);
				}
			}
		}

		public void SetPatLever()
		{
			Patlever.Clear();
			for (int i = 0; i < 256; i++)
			{
				if (i == 0)
				{
					Patlever.Add(0, 80.0);
				}
				else if (i < 10)
				{
					Patlever.Add(i, Patlever[i - 1] * 1.5);
				}
				else if (i < 35)
				{
					Patlever.Add(i, Patlever[i - 1] * 1.3);
				}
				else if (i < 60)
				{
					Patlever.Add(i, Patlever[i - 1] * 1.2);
				}
				else if (i < 80)
				{
					Patlever.Add(i, Patlever[i - 1] * 1.12);
				}
				else if (i < 100)
				{
					Patlever.Add(i, Patlever[i - 1] * 1.1);
				}
				else
				{
					Patlever.Add(i, Patlever[i - 1] * 1.07);
				}
			}
		}

		public void SetMover()
		{
			string sqlCommand = "SELECT * FROM TBL_移动数据";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载移动出错----没有移动数据");
			}
			else
			{
				Mover.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					MoveClass moveClass = new MoveClass();
					moveClass.MAP = (int)dBToDataTable.Rows[i]["MAP"];
					moveClass.X = float.Parse(dBToDataTable.Rows[i]["X"].ToString());
					moveClass.Y = float.Parse(dBToDataTable.Rows[i]["Y"].ToString());
					moveClass.Z = float.Parse(dBToDataTable.Rows[i]["Z"].ToString());
					moveClass.ToMAP = (int)dBToDataTable.Rows[i]["ToMAP"];
					moveClass.ToX = float.Parse(dBToDataTable.Rows[i]["ToX"].ToString());
					moveClass.ToY = float.Parse(dBToDataTable.Rows[i]["ToY"].ToString());
					moveClass.ToZ = float.Parse(dBToDataTable.Rows[i]["ToZ"].ToString());
					Mover.Add(moveClass);
				}
				Form1.WriteLine(3, "加载传送点数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetKONGFU()
		{
			string sqlCommand = "SELECT * FROM TBL_功夫数据";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载武功出错----没有武功数据");
			}
			else
			{
				TBL_KONGFU.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					武功类 武功类 = new 武功类();
					武功类.FLD_AT = (int)dBToDataTable.Rows[i]["FLD_AT"];
					武功类.FLD_EFFERT = (int)dBToDataTable.Rows[i]["FLD_EFFERT"];
					武功类.FLD_INDEX = (int)dBToDataTable.Rows[i]["FLD_INDEX"];
					武功类.FLD_JOB = (int)dBToDataTable.Rows[i]["FLD_JOB"];
					武功类.FLD_JOBLEVEL = (int)dBToDataTable.Rows[i]["FLD_JOBLEVEL"];
					武功类.FLD_LEVEL = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
					武功类.FLD_MP = (int)dBToDataTable.Rows[i]["FLD_MP"];
					武功类.FLD_NEEDEXP = (int)dBToDataTable.Rows[i]["FLD_NEEDEXP"];
					武功类.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
					武功类.FLD_TYPE = (int)dBToDataTable.Rows[i]["FLD_TYPE"];
					武功类.FLD_ZX = (int)dBToDataTable.Rows[i]["FLD_ZX"];
					武功类.FLD_阶段数量 = (int)dBToDataTable.Rows[i]["FLD_阶段数量"];
					武功类.FLD_攻击数量 = (int)dBToDataTable.Rows[i]["FLD_攻击数量"];
					武功类.FLD_武功类型 = (int)dBToDataTable.Rows[i]["FLD_武功类型"];
					武功类.FLD_冷却时间 = (int)dBToDataTable.Rows[i]["FLD_冷却时间"];
					武功类.FLD_攻击确认时间 = (int)dBToDataTable.Rows[i]["FLD_攻击确认时间"];
					TBL_KONGFU.Add(武功类.FLD_PID, 武功类);
				}
				Form1.WriteLine(3, "加载武功数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetItme()
		{
			string sqlCommand = "SELECT * FROM TBL_物品列表";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载物品出错----没有物品数据");
			}
			else
			{
				Itme.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					ItmeClass itmeClass = new ItmeClass();
					itmeClass.FLD_NJ = (int)dBToDataTable.Rows[i]["FLD_NJ"];
					itmeClass.FLD_AT = (int)dBToDataTable.Rows[i]["FLD_AT1"];
					itmeClass.FLD_AT_Max = (int)dBToDataTable.Rows[i]["FLD_AT2"];
					itmeClass.FLD_DF = (int)dBToDataTable.Rows[i]["FLD_DF"];
					itmeClass.FLD_RESIDE1 = (int)dBToDataTable.Rows[i]["FLD_RESIDE1"];
					itmeClass.FLD_RESIDE2 = (int)dBToDataTable.Rows[i]["FLD_RESIDE2"];
					itmeClass.FLD_JOB_LEVEL = (int)dBToDataTable.Rows[i]["FLD_JOB_LEVEL"];
					itmeClass.FLD_LEVEL = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
					itmeClass.FLD_MONEY = (int)dBToDataTable.Rows[i]["FLD_MONEY"];
					itmeClass.FLD_PID = int.Parse(dBToDataTable.Rows[i]["FLD_PID"].ToString());
					itmeClass.FLD_SEX = (int)dBToDataTable.Rows[i]["FLD_SEX"];
					itmeClass.FLD_WEIGHT = (int)dBToDataTable.Rows[i]["FLD_WEIGHT"];
					itmeClass.FLD_ZX = (int)dBToDataTable.Rows[i]["FLD_ZX"];
					itmeClass.FLD_SIDE = (int)dBToDataTable.Rows[i]["FLD_SIDE"];
					itmeClass.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					itmeClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					itmeClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					itmeClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					itmeClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC5"];
					itmeClass.FLD_XW = (int)dBToDataTable.Rows[i]["FLD_WX"];
					itmeClass.FLD_XWJD = (int)dBToDataTable.Rows[i]["FLD_WXJD"];
					itmeClass.FLD_TYPE = (int)dBToDataTable.Rows[i]["FLD_TYPE"];
					itmeClass.FLD_QUESTITEM = (int)dBToDataTable.Rows[i]["FLD_QUESTITEM"];
					itmeClass.FLD_HEAD_WEAR = (int)dBToDataTable.Rows[i]["FLD_HEAD_WEAR"];
					itmeClass.ItmeNAME = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
					itmeClass.FLD_LOCK = (int)dBToDataTable.Rows[i]["FLD_LOCK"];
					Itme.Add(itmeClass.FLD_PID, itmeClass);
				}
				Form1.WriteLine(3, "加载物品数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetShot()
		{
			string sqlCommand = "SELECT * FROM TBL_商店物品 ORDER BY FLD_INDEX";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载物品商店----没有物品数据");
			}
			else
			{
				Shot.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					ShotClass shotClass = new ShotClass();
					shotClass.FLD_NID = int.Parse(dBToDataTable.Rows[i]["FLD_NID"].ToString());
					shotClass.FLD_INDEX = (int)dBToDataTable.Rows[i]["FLD_INDEX"];
					shotClass.FLD_PID = int.Parse(dBToDataTable.Rows[i]["FLD_PID"].ToString());
					shotClass.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
					shotClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					shotClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					shotClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					shotClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					shotClass.WX = (int)dBToDataTable.Rows[i]["FLD_WX"];
					shotClass.NEEDWX = (int)dBToDataTable.Rows[i]["FLD_NEEDWX"];
					Shot.Add(shotClass);
				}
				Form1.WriteLine(3, "加载物品商店完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetDrop()
		{
			try
			{
				string sqlCommand = "SELECT * FROM TBL_掉落_普通怪 ORDER BY FLD_LEVEL1, FLD_LEVEL2";
				DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
				if (dBToDataTable != null)
				{
					if (dBToDataTable.Rows.Count == 0)
					{
						Form1.WriteLine(3, "加载掉落物品完成----没有物品数据");
					}
					else
					{
						Drop.Clear();
						for (int i = 0; i < dBToDataTable.Rows.Count; i++)
						{
							DropClass dropClass = new DropClass();
							try
							{
								dropClass.id = (int)dBToDataTable.Rows[i]["id"];
								dropClass.FLD_NPC = (int)dBToDataTable.Rows[i]["FLD_掉落怪物ID"];
								dropClass.FLD_LEVEL1 = (int)dBToDataTable.Rows[i]["FLD_LEVEL1"];
								dropClass.FLD_LEVEL2 = (int)dBToDataTable.Rows[i]["FLD_LEVEL2"];
								dropClass.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
								dropClass.FLD_PP = (int)dBToDataTable.Rows[i]["FLD_PP"];
								dropClass.FLD_NAME = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
								dropClass.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
								dropClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
								dropClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
								dropClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
								dropClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
								dropClass.FLD_MAGICNew0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
								dropClass.FLD_MAGICNew1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
								dropClass.FLD_MAGICNew2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
								dropClass.FLD_MAGICNew3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
								dropClass.FLD_MAGICNew4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
								dropClass.是否提示 = (int)dBToDataTable.Rows[i]["是否提示"];
								dropClass.需要金符 = (int)dBToDataTable.Rows[i]["需要金符"];
								Drop.Add(dropClass);
							}
							catch (Exception ex)
							{
								Form1.WriteLine(1, "加载掉落物品 错误" + dropClass.FLD_NAME + "  " + ex.Message);
							}
						}
						Form1.WriteLine(3, "加载掉落物品 " + dBToDataTable.Rows.Count.ToString());
					}
					dBToDataTable.Dispose();
				}
			}
			catch (Exception ex2)
			{
				Form1.WriteLine(1, "加载掉落物品 错误" + ex2.Message);
			}
		}

		public void Set_GSDrop()
		{
			string sqlCommand = "SELECT * FROM TBL_掉落_高手怪 ORDER BY FLD_LEVEL1, FLD_LEVEL2";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载高手怪掉落物品完成----没有物品数据");
			}
			else
			{
				Drop_GS.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					DropClass dropClass = new DropClass();
					try
					{
						dropClass.id = (int)dBToDataTable.Rows[i]["id"];
						dropClass.FLD_NPC = (int)dBToDataTable.Rows[i]["FLD_掉落怪物ID"];
						dropClass.FLD_LEVEL1 = (int)dBToDataTable.Rows[i]["FLD_LEVEL1"];
						dropClass.FLD_LEVEL2 = (int)dBToDataTable.Rows[i]["FLD_LEVEL2"];
						dropClass.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						dropClass.FLD_PP = (int)dBToDataTable.Rows[i]["FLD_PP"];
						dropClass.FLD_NAME = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
						dropClass.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
						dropClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
						dropClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
						dropClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
						dropClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
						dropClass.FLD_MAGICNew0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
						dropClass.FLD_MAGICNew1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
						dropClass.FLD_MAGICNew2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
						dropClass.FLD_MAGICNew3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
						dropClass.FLD_MAGICNew4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
						dropClass.是否提示 = (int)dBToDataTable.Rows[i]["是否提示"];
						Drop_GS.Add(dropClass);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载掉落物品 错误" + dropClass.FLD_NAME + "  " + ex.Message);
					}
				}
				Form1.WriteLine(3, "加载高手怪落物品 " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetBossDrop()
		{
			string sqlCommand = "SELECT * FROM TBL_掉落_BOSS ORDER BY FLD_LEVEL1, FLD_LEVEL2";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载BOSS掉落物品完成----没有物品数据");
			}
			else
			{
				BossDrop.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					DropClass dropClass = new DropClass();
					try
					{
						dropClass.id = (int)dBToDataTable.Rows[i]["id"];
						dropClass.FLD_NPC = (int)dBToDataTable.Rows[i]["FLD_掉落怪物ID"];
						dropClass.FLD_LEVEL1 = (int)dBToDataTable.Rows[i]["FLD_LEVEL1"];
						dropClass.FLD_LEVEL2 = (int)dBToDataTable.Rows[i]["FLD_LEVEL2"];
						dropClass.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						dropClass.FLD_PP = (int)dBToDataTable.Rows[i]["FLD_PP"];
						dropClass.FLD_NAME = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
						dropClass.FLD_MAGIC0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
						dropClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
						dropClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
						dropClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
						dropClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
						dropClass.FLD_MAGICNew0 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
						dropClass.FLD_MAGICNew1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
						dropClass.FLD_MAGICNew2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
						dropClass.FLD_MAGICNew3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
						dropClass.FLD_MAGICNew4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
						dropClass.是否提示 = (int)dBToDataTable.Rows[i]["是否提示"];
						BossDrop.Add(dropClass);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载掉落物品 错误" + dropClass.FLD_NAME + "  " + ex.Message);
					}
				}
				Form1.WriteLine(3, "加载BOSS掉落物品 " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetOpen()
		{
			string sqlCommand = "SELECT * FROM TBL_开箱数据";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载开箱物品完成----没有开箱物品数据");
			}
			else
			{
				Open.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					OpenClass openClass = new OpenClass();
					openClass.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
					openClass.FLD_PIDX = (int)dBToDataTable.Rows[i]["FLD_PIDX"];
					openClass.FLD_NUMBER = (int)dBToDataTable.Rows[i]["FLD_NUMBER"];
					openClass.FLD_PP = (int)dBToDataTable.Rows[i]["FLD_PP"];
					openClass.FLD_NAME = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
					openClass.FLD_NAMEX = dBToDataTable.Rows[i]["FLD_NAMEX"].ToString();
					openClass.FLD_MAGIC1 = (int)dBToDataTable.Rows[i]["FLD_MAGIC0"];
					openClass.FLD_MAGIC2 = (int)dBToDataTable.Rows[i]["FLD_MAGIC1"];
					openClass.FLD_MAGIC3 = (int)dBToDataTable.Rows[i]["FLD_MAGIC2"];
					openClass.FLD_MAGIC4 = (int)dBToDataTable.Rows[i]["FLD_MAGIC3"];
					openClass.FLD_MAGIC5 = (int)dBToDataTable.Rows[i]["FLD_MAGIC4"];
					openClass.是否提示 = (int)dBToDataTable.Rows[i]["是否提示"];
					Open.Add(openClass);
				}
				Form1.WriteLine(3, "加载开箱物品 " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetDBConfig()
		{
			string sqlCommand = "SELECT * FROM TBL_配置数据";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable != null)
			{
				if (dBToDataTable.Rows.Count == 0)
				{
					Form1.WriteLine(3, "加载数据库配置数据----没有数据");
				}
				else
				{
					Form1.WriteLine(3, "加载配置数据完成 " + dBToDataTable.Rows.Count.ToString());
				}
				dBToDataTable.Dispose();
			}
		}

		public void 加载假人喊话内容()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT   *   FROM   TBL_XWWL_假人喊话内容", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(2, "加载假人喊话内容数据完成----没有假人喊话内容");
			}
			else
			{
				假人hanhua.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						假人喊话 假人喊话 = new 假人喊话();
						假人喊话.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						假人喊话.假人模式 = (int)dBToDataTable.Rows[i]["假人模式"];
						假人喊话.喊话内容 = dBToDataTable.Rows[i]["喊话内容"].ToString();
						假人hanhua.Add(i, 假人喊话);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载假人喊话内容数据   出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(2, "加载假人喊话内容数据完成   " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void 加载假人怪物坐标()
		{
			DataTable dBToDataTable = DBA.GetDBToDataTable("SELECT   *   FROM   TBL_怪物列表", "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(2, "加载假人怪物数据完成----没有怪物数据");
			}
			else
			{
				假人.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						假人坐标 假人坐标 = new 假人坐标();
						假人坐标.FLD_INDEX = (int)dBToDataTable.Rows[i]["FLD_INDEX"];
						假人坐标.FLD_MID = (int)dBToDataTable.Rows[i]["FLD_MID"];
						假人坐标.Level = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
						假人坐标.Rxjh_X = float.Parse(dBToDataTable.Rows[i]["FLD_X"].ToString());
						假人坐标.Rxjh_Y = float.Parse(dBToDataTable.Rows[i]["FLD_Y"].ToString());
						假人.Add(i, 假人坐标);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载假人怪物数据   出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(2, "加载假人怪物数据完成   " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void 加载假人商店物品列表()
		{
			假人出售物品列表 = new List<TBL_假人出售物品>();
			假人出售物品列表.Clear();
			假人出售物品列表 = RxjhClass.获取假人商店物品();
		}

		public void SetMonSter()
		{
			string sqlCommand = "SELECT * FROM TBL_NPC列表";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载怪物数据完成----没有怪物数据");
			}
			else
			{
				MonSter.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						MonSterClss monSterClss = new MonSterClss();
						monSterClss.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						monSterClss.FLD_AT = (int)dBToDataTable.Rows[i]["FLD_AT"];
						monSterClss.FLD_AUTO = (int)dBToDataTable.Rows[i]["FLD_AUTO"];
						monSterClss.FLD_BOSS = (int)dBToDataTable.Rows[i]["FLD_BOSS"];
						monSterClss.FLD_DF = (int)dBToDataTable.Rows[i]["FLD_DF"];
						monSterClss.Level = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
						monSterClss.Name = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
						monSterClss.Rxjh_Exp = (int)dBToDataTable.Rows[i]["FLD_EXP"];
						monSterClss.Rxjh_HP = (int)dBToDataTable.Rows[i]["FLD_HP"];
						MonSter.Add(monSterClss.FLD_PID, monSterClss);
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载怪物数据 出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(3, "加载怪物数据完成 " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void Set石头属性()
		{
			string sqlCommand = "SELECT * FROM 石头属性效果";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载石头数据出错----没有石头数据");
			}
			else
			{
				石头属性调整.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					石头属性调整类 石头属性调整类 = new 石头属性调整类();
					石头属性调整类.类型 = (int)dBToDataTable.Rows[i]["FLD_TYPE"];
					石头属性调整类.数量 = (int)dBToDataTable.Rows[i]["FLD_VALUE"];
					石头属性调整类.加减 = (int)dBToDataTable.Rows[i]["FLD_增减"];
					石头属性调整.Add(i, 石头属性调整类);
				}
				Form1.WriteLine(3, "加载石头石头数据完成" + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public void SetNpc()
		{
			string sqlCommand = (ver != 1) ? "SELECT * FROM TBL_怪物列表 WHERE FLD_BOSS < 11" : "SELECT * FROM TBL_怪物列表";
			DataTable dBToDataTable = DBA.GetDBToDataTable(sqlCommand, "PublicDb");
			if (dBToDataTable == null)
			{
				return;
			}
			if (dBToDataTable.Rows.Count == 0)
			{
				Form1.WriteLine(3, "加载NPC数据出错----没有NPC数据");
			}
			else
			{
				Map.Clear();
				for (int i = 0; i < dBToDataTable.Rows.Count; i++)
				{
					try
					{
						NpcClass npcClass = new NpcClass();
						npcClass.FLD_PID = (int)dBToDataTable.Rows[i]["FLD_PID"];
						if (当前线路类型 != 1 || npcClass.FLD_PID < 99999)
						{
							npcClass.Name = dBToDataTable.Rows[i]["FLD_NAME"].ToString();
							npcClass.Level = (int)dBToDataTable.Rows[i]["FLD_LEVEL"];
							npcClass.Rxjh_Exp = (int)dBToDataTable.Rows[i]["FLD_EXP"];
							npcClass.Rxjh_X = float.Parse(dBToDataTable.Rows[i]["FLD_X"].ToString());
							npcClass.Rxjh_Y = float.Parse(dBToDataTable.Rows[i]["FLD_Y"].ToString());
							npcClass.Rxjh_Z = float.Parse(dBToDataTable.Rows[i]["FLD_Z"].ToString());
							npcClass.Rxjh_cs_X = float.Parse(dBToDataTable.Rows[i]["FLD_X"].ToString());
							npcClass.Rxjh_cs_Y = float.Parse(dBToDataTable.Rows[i]["FLD_Y"].ToString());
							npcClass.Rxjh_cs_Z = float.Parse(dBToDataTable.Rows[i]["FLD_Z"].ToString());
							npcClass.IsNpc = (int)dBToDataTable.Rows[i]["FLD_NPC"];
							npcClass.FLD_FACE1 = float.Parse(dBToDataTable.Rows[i]["FLD_FACE0"].ToString());
							npcClass.FLD_FACE2 = float.Parse(dBToDataTable.Rows[i]["FLD_FACE"].ToString());
							npcClass.Rxjh_Map = (int)dBToDataTable.Rows[i]["FLD_MID"];
							npcClass.Max_Rxjh_HP = (int)dBToDataTable.Rows[i]["FLD_HP"];
							npcClass.Rxjh_HP = (int)dBToDataTable.Rows[i]["FLD_HP"];
							npcClass.FLD_AT = (int)dBToDataTable.Rows[i]["FLD_AT"];
							npcClass.FLD_DF = (int)dBToDataTable.Rows[i]["FLD_DF"];
							npcClass.FLD_AUTO = (int)dBToDataTable.Rows[i]["FLD_AUTO"];
							npcClass.FLD_BOSS = (int)dBToDataTable.Rows[i]["FLD_BOSS"];
							npcClass.FLD_NEWTIME = (int)dBToDataTable.Rows[i]["FLD_NEWTIME"];
							if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value))
							{
								value.add(npcClass);
							}
							else
							{
								value = new MapClass();
								value.MapID = npcClass.Rxjh_Map;
								value.add(npcClass);
								Map.Add(value.MapID, value);
							}
						}
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "加载NPC数据 出错：" + ex?.ToString());
					}
				}
				Form1.WriteLine(3, "加载NPC数据完成 " + dBToDataTable.Rows.Count.ToString());
			}
			dBToDataTable.Dispose();
		}

		public static void delNpc(int MAP)
		{
			try
			{
				List<NpcClass> list = new List<NpcClass>();
				foreach (NpcClass value in MapClass.GetnpcTemplate(MAP).Values)
				{
					list.Add(value);
				}
				foreach (NpcClass item in list)
				{
					item.Dispose();
				}
				list.Clear();
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "删除NPC数据 出错：" + ex?.ToString());
			}
		}

		public static int AddBossEveNpc(int Npcid, float x, float y, int mapp)
		{
			try
			{
				if (MonSter.TryGetValue(Npcid, out MonSterClss value))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = value.FLD_PID;
					npcClass.Name = value.Name;
					npcClass.Level = value.Level;
					npcClass.Rxjh_Exp = value.Rxjh_Exp;
					npcClass.Rxjh_X = x;
					npcClass.Rxjh_Y = y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = x;
					npcClass.Rxjh_cs_Y = y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = mapp;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = 0f;
					npcClass.FLD_FACE2 = 0f;
					npcClass.Max_Rxjh_HP = value.Rxjh_HP;
					npcClass.Rxjh_HP = value.Rxjh_HP;
					npcClass.FLD_AT = value.FLD_AT;
					npcClass.FLD_DF = value.FLD_DF;
					npcClass.FLD_AUTO = value.FLD_AUTO;
					npcClass.FLD_BOSS = value.FLD_BOSS;
					npcClass.一次性怪 = true;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						value2 = new MapClass();
						value2.MapID = npcClass.Rxjh_Map;
						value2.add(npcClass);
						Map.Add(value2.MapID, value2);
					}
					npcClass.获取范围玩家发送增加数据包();
					Thread.Sleep(1);
					return npcClass.FLD_INDEX;
				}
				return 0;
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "增加BOSS攻城怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
				return 0;
			}
		}

		public static int 统计地图怪物数量(int mapp)
		{
			try
			{
				int num = 0;
				foreach (NpcClass value in MapClass.GetnpcTemplate(mapp).Values)
				{
					num++;
				}
				return num;
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "统计地图怪物数量 [" + mapp.ToString() + "]出错：" + ex?.ToString());
				return 0;
			}
		}

		public static void delNpcq(int mapp, int Npcid)
		{
			try
			{
				List<NpcClass> list = new List<NpcClass>();
				foreach (NpcClass value in MapClass.GetnpcTemplate(mapp).Values)
				{
					if (value.FLD_PID == Npcid)
					{
						list.Add(value);
					}
				}
				foreach (NpcClass item in list)
				{
					item.Dispose();
				}
				list.Clear();
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "删除怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void delNpc(int mapp, int Npcid)
		{
			try
			{
				List<NpcClass> list = new List<NpcClass>();
				foreach (NpcClass value in MapClass.GetnpcTemplate(mapp).Values)
				{
					if (value.FLD_PID == Npcid)
					{
						list.Add(value);
					}
				}
				foreach (NpcClass item in list)
				{
					item.Dispose();
				}
				list.Clear();
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "删除怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void AddNpc(int Npcid, float x, float y, int mapp)
		{
			try
			{
				if (MonSter.TryGetValue(Npcid, out MonSterClss value))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = value.FLD_PID;
					npcClass.Name = value.Name;
					npcClass.Level = value.Level;
					npcClass.Rxjh_Exp = value.Rxjh_Exp;
					npcClass.Rxjh_X = x;
					npcClass.Rxjh_Y = y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = x;
					npcClass.Rxjh_cs_Y = y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = mapp;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = 0f;
					npcClass.FLD_FACE2 = 0f;
					npcClass.Max_Rxjh_HP = value.Rxjh_HP;
					npcClass.Rxjh_HP = value.Rxjh_HP;
					npcClass.FLD_AT = value.FLD_AT;
					npcClass.FLD_DF = value.FLD_DF;
					npcClass.FLD_AUTO = value.FLD_AUTO;
					npcClass.FLD_BOSS = value.FLD_BOSS;
					npcClass.一次性怪 = true;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						value2 = new MapClass();
						value2.MapID = npcClass.Rxjh_Map;
						value2.add(npcClass);
						Map.Add(value2.MapID, value2);
					}
					npcClass.获取范围玩家发送增加数据包();
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "增加怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void AddNpc(int Npcid, float x, float y, int mapp, int BOSS)
		{
			try
			{
				if (MonSter.TryGetValue(Npcid, out MonSterClss value))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = value.FLD_PID;
					npcClass.Name = value.Name;
					npcClass.Level = value.Level;
					npcClass.Rxjh_Exp = value.Rxjh_Exp;
					npcClass.Rxjh_X = x;
					npcClass.Rxjh_Y = y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = x;
					npcClass.Rxjh_cs_Y = y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = mapp;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = 0f;
					npcClass.FLD_FACE2 = 0f;
					npcClass.Max_Rxjh_HP = value.Rxjh_HP;
					npcClass.Rxjh_HP = value.Rxjh_HP;
					npcClass.FLD_AT = value.FLD_AT;
					npcClass.FLD_DF = value.FLD_DF;
					npcClass.FLD_AUTO = value.FLD_AUTO;
					npcClass.FLD_BOSS = BOSS;
					npcClass.一次性怪 = true;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						value2 = new MapClass();
						value2.MapID = npcClass.Rxjh_Map;
						value2.add(npcClass);
						Map.Add(value2.MapID, value2);
					}
					npcClass.获取范围玩家发送增加数据包();
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "增加怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void AddNpc一次(int 怪物ID, float 坐标X, float 坐标Y, int 地图, bool 是否true, int 血, int 攻击, int 防御)
		{
			try
			{
				if (MonSter.TryGetValue(怪物ID, out MonSterClss _))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = 怪物ID;
					npcClass.Name = "BOSS世界";
					npcClass.Level = 1;
					npcClass.Rxjh_Exp = 1;
					npcClass.Rxjh_X = 坐标X;
					npcClass.Rxjh_Y = 坐标Y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = 坐标X;
					npcClass.Rxjh_cs_Y = 坐标Y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = 地图;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = 0f;
					npcClass.FLD_FACE2 = 0f;
					npcClass.Max_Rxjh_HP = 血;
					npcClass.Rxjh_HP = 血;
					npcClass.FLD_AT = 攻击;
					npcClass.FLD_DF = 防御;
					npcClass.FLD_AUTO = 1;
					npcClass.FLD_BOSS = 0;
					npcClass.一次性怪 = true;
					npcClass.FLD_NEWTIME = 10;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						MapClass mapClass = new MapClass();
						mapClass.MapID = npcClass.Rxjh_Map;
						mapClass.add(npcClass);
						Map.Add(mapClass.MapID, mapClass);
					}
					npcClass.获取范围玩家发送增加数据包();
				}
				else
				{
					Form1.WriteLine(2, "增加怪一次  [" + 怪物ID.ToString() + "]错误1");
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(2, "增加怪一次  [" + 怪物ID.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void AddNpc(int Npcid, float x, float y, int mapp, int FLD_FACE1, int FLD_FACE2, bool 一次性怪, int FLD_NEWTIME)
		{
			try
			{
				if (MonSter.TryGetValue(Npcid, out MonSterClss value))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = value.FLD_PID;
					npcClass.Name = value.Name;
					npcClass.Level = value.Level;
					npcClass.Rxjh_Exp = value.Rxjh_Exp;
					npcClass.Rxjh_X = x;
					npcClass.Rxjh_Y = y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = x;
					npcClass.Rxjh_cs_Y = y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = mapp;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = FLD_FACE1;
					npcClass.FLD_FACE2 = FLD_FACE2;
					npcClass.Max_Rxjh_HP = value.Rxjh_HP;
					npcClass.Rxjh_HP = value.Rxjh_HP;
					npcClass.FLD_AT = value.FLD_AT;
					npcClass.FLD_DF = value.FLD_DF;
					npcClass.FLD_AUTO = value.FLD_AUTO;
					npcClass.FLD_BOSS = value.FLD_BOSS;
					npcClass.一次性怪 = 一次性怪;
					npcClass.FLD_NEWTIME = FLD_NEWTIME;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						value2 = new MapClass();
						value2.MapID = npcClass.Rxjh_Map;
						value2.add(npcClass);
						Map.Add(value2.MapID, value2);
					}
					npcClass.获取范围玩家发送增加数据包();
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "增加怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void SerNpc(int Npcid, float x, float y, int mapp)
		{
			try
			{
				if (MonSter.TryGetValue(Npcid, out MonSterClss value))
				{
					NpcClass npcClass = new NpcClass();
					npcClass.FLD_PID = value.FLD_PID;
					npcClass.Name = value.Name;
					npcClass.Level = value.Level;
					npcClass.Rxjh_Exp = value.Rxjh_Exp;
					npcClass.Rxjh_X = x;
					npcClass.Rxjh_Y = y;
					npcClass.Rxjh_Z = 15f;
					npcClass.Rxjh_cs_X = x;
					npcClass.Rxjh_cs_Y = y;
					npcClass.Rxjh_cs_Z = 15f;
					npcClass.Rxjh_Map = mapp;
					npcClass.IsNpc = 0;
					npcClass.FLD_FACE1 = 0f;
					npcClass.FLD_FACE2 = 0f;
					npcClass.Max_Rxjh_HP = value.Rxjh_HP;
					npcClass.Rxjh_HP = value.Rxjh_HP;
					npcClass.FLD_AT = value.FLD_AT;
					npcClass.FLD_DF = value.FLD_DF;
					npcClass.FLD_AUTO = value.FLD_AUTO;
					npcClass.FLD_BOSS = value.FLD_BOSS;
					if (Map.TryGetValue(npcClass.Rxjh_Map, out MapClass value2))
					{
						value2.add(npcClass);
					}
					else
					{
						value2 = new MapClass();
						value2.MapID = npcClass.Rxjh_Map;
						value2.add(npcClass);
						Map.Add(value2.MapID, value2);
					}
					npcClass.获取范围玩家发送增加数据包();
					string sqlCommand = $"INSERT INTO TBL_怪物列表(FLD_PID,FLD_X,FLD_Y,FLD_Z,FLD_FACE0,FLD_FACE,FLD_MID,FLD_NAME,FLD_HP,FLD_AT,FLD_DF,FLD_NPC,FLD_NEWTIME,FLD_LEVEL,FLD_EXP,FLD_AUTO,FLD_BOSS)VALUES ({npcClass.FLD_PID},{x},{y},{15},{0},{0},{npcClass.Rxjh_Map},'{npcClass.Name}',{npcClass.Max_Rxjh_HP},{npcClass.FLD_AT},{npcClass.FLD_DF},{0},{10},{npcClass.Level},{npcClass.Rxjh_Exp},{npcClass.FLD_AUTO},{npcClass.FLD_BOSS})";
					DBA.ExeSqlCommand(sqlCommand, "PublicDb");
				}
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "增加怪 [" + Npcid.ToString() + "]出错：" + ex?.ToString());
			}
		}

		public static void 随机BOSS系统()
		{
			Random random = new Random();
			try
			{
				List<MonSterClss> list = new List<MonSterClss>();
				foreach (MonSterClss value in MonSter.Values)
				{
					if (value.FLD_BOSS == 1)
					{
						list.Add(value);
					}
				}
				int index = random.Next(0, list.Count);
				AddNpc(list[index].FLD_PID, random.Next(420, 700), random.Next(1700, 2000), 101);
				AddNpc(list[index].FLD_PID, random.Next(420, 700), random.Next(1700, 2000), 101);
				string msg = "泫勃派已经被BOSS侵袭，门主发出求救,赶紧带着小伙伴们去反击入侵者:" + list[index].Name;
				发送公告(msg);
			}
			catch (Exception ex)
			{
				Form1.WriteLine(1, "加载NPC数据 出错：" + ex?.ToString());
			}
		}

		public static void ProcessSqlQueue()
		{
			try
			{
				if (jlMsg == 1)
				{
					Form1.WriteLine(1, "ProcessSqlQueue111()");
				}
				while (SqlPool.Count > 0)
				{
					if (jlMsg == 1)
					{
						Form1.WriteLine(1, "ProcessSqlQueue");
					}
					DbPoolClass dbPoolClass = (DbPoolClass)SqlPool.Dequeue();
					try
					{
						if (DbPoolClass.DbPoolClassRun(dbPoolClass.Conn, dbPoolClass.Sql, dbPoolClass.Prams, dbPoolClass.Type) == -1)
						{
							Form1.WriteLine(1, "ProcessSqlQueue()2 数据库连接出错 " + SqlPool.Count.ToString());
							Thread.Sleep(1);
						}
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "ProcessSqlQueue()1出错 " + ex?.ToString());
						Thread.Sleep(1);
					}
				}
			}
			catch (Exception ex2)
			{
				Form1.WriteLine(1, "ProcessSqlQueue()出错 " + ex2?.ToString());
			}
		}

		public static void ProcessDisposedQueue()
		{
			int num = 0;
			try
			{
				if (jlMsg == 1)
				{
					Form1.WriteLine(1, "ProcessDisposedQueue111()");
				}
				int num2 = 0;
				while (num2 < 200 && m_Disposed.Count > 0)
				{
					if (jlMsg == 1)
					{
						Form1.WriteLine(1, "ProcessDisposedQueue");
					}
					num2++;
					NetState netState = (NetState)m_Disposed.Dequeue();
					try
					{
						num = 1;
						if (netState != null)
						{
							num = 2;
							if (netState.在线)
							{
								netState.IDout();
							}
							num = 3;
							if (netState.Player != null)
							{
								num = 4;
								netState.Player.退出中 = true;
								netState.Player.Logout();
								num = 5;
								netState.Player.Dispose();
							}
							num = 6;
							if (allConnectedChars.ContainsKey(netState.WorldId))
							{
								num = 7;
								allConnectedChars.Remove(netState.WorldId);
							}
							num = 8;
							netState.Player = null;
							num = 9;
							netState.delWorldIdd();
							num = 10;
						}
						else
						{
							Form1.WriteLine(1, "ns is null");
						}
					}
					catch (Exception ex)
					{
						Form1.WriteLine(1, "ProcessDisposedQueue()出错 " + num.ToString() + "  " + ex.Message);
					}
				}
			}
			catch (Exception ex2)
			{
				Form1.WriteLine(1, "ProcessDisposedQueue()出错2 " + num.ToString() + " 数据队列:" + m_Disposed.Count.ToString() + "  " + ex2.Message);
			}
		}

		public static string pWord(string sSource, int iFlag)
		{
			if (sSource == null)
			{
				return null;
			}
			if (sSource.Equals(""))
			{
				return "";
			}
			string text = "";
			if (iFlag == 2)
			{
				int length = sSource.Length;
				text = "";
				int num = Convert.ToInt32(sSource.ToCharArray(0, 1)[0]) % 10;
				for (int i = 2; i < length; i += 2)
				{
					int num2 = Convert.ToInt32(sSource.ToCharArray(i, 1)[0]);
					string str = (Convert.ToInt32(sSource.ToCharArray(i - 1, 1)[0]) % 2 != 0) ? ((char)(num2 - (i - 1) / 2 - num)).ToString() : ((char)(num2 + (i - 1) / 2 + num)).ToString();
					text += str;
				}
			}
			return text;
		}
	}
}
